//  Boost string_algo library sequence_traits.hpp header file  ---------------------------//



//  Copyright Pavol Droba 2002-2003.

//

// Distributed under the Boost Software License, Version 1.0.

//    (See accompanying file LICENSE_1_0.txt or copy at

//          http://www.boost.org/LICENSE_1_0.txt)



//  See http://www.boost.org/ for updates, documentation, and revision history.



#ifndef BOOST_STRING_SEQUENCE_TRAITS_HPP

#define BOOST_STRING_SEQUENCE_TRAITS_HPP



#include <boost/config.hpp>

#include <boost/mpl/bool.hpp>

#include <boost/algorithm/string/yes_no_type.hpp>



/*! \file

    Traits defined in this header are used by various algorithms to achieve

    better performance for specific containers.

    Traits provide fail-safe defaults. If a container supports some of these

    features, it is possible to specialize the specific trait for this container.

    For lacking compilers, it is possible of define an override for a specific tester

    function.



    Due to a language restriction, it is not currently possible to define specializations for

    stl containers without including the corresponding header. To decrease the overhead

    needed by this inclusion, user can selectively include a specialization

    header for a specific container. They are located in boost/algorithm/string/stl

    directory. Alternatively she can include boost/algorithm/string/std_collection_traits.hpp

    header which contains specializations for all stl containers.

*/



namespace boost {

    namespace algorithm {



//  sequence traits  -----------------------------------------------//



#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION



        //! Native replace tester

        /*!

            Declare an override of this tester function with return

            type boost::string_algo::yes_type for a sequence with this property.



            \return yes_type if the container has basic_string like native replace

            method.

        */

        no_type has_native_replace_tester(...);



        //! Stable iterators tester

        /*!

            Declare an override of this tester function with return

            type boost::string_algo::yes_type for a sequence with this property.



            \return yes_type if the sequence's insert/replace/erase methods do not invalidate

            existing iterators.

        */

        no_type has_stable_iterators_tester(...);



        //! const time insert tester

        /*!

            Declare an override of this tester function with return

            type boost::string_algo::yes_type for a sequence with this property.



            \return yes_type if the sequence's insert method is working in constant time

        */

        no_type has_const_time_insert_tester(...);



        //! const time erase tester

        /*!

            Declare an override of this tester function with return

            type boost::string_algo::yes_type for a sequence with this property.



            \return yes_type if the sequence's erase method is working in constant time

        */

        no_type has_const_time_erase_tester(...);



#endif //BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION



        //! Native replace trait

        /*!

            This trait specifies that the sequence has \c std::string like replace method

        */

        template< typename T >

        class has_native_replace

        {



#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

        private:

            static T* t;

        public:

            BOOST_STATIC_CONSTANT(bool, value=(

                sizeof(has_native_replace_tester(t))==sizeof(yes_type) ) );

#else  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

        public:

#    if BOOST_WORKAROUND( __IBMCPP__, <= 600 )

            enum { value = false };

#    else

            BOOST_STATIC_CONSTANT(bool, value=false);

#    endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )

#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION





            typedef mpl::bool_<has_native_replace<T>::value> type;

        };





        //! Stable iterators trait

        /*!

            This trait specifies that the sequence has stable iterators. It means

            that operations like insert/erase/replace do not invalidate iterators.

        */

        template< typename T >

        class has_stable_iterators

        {

#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

        private:

            static T* t;

        public:

            BOOST_STATIC_CONSTANT(bool, value=(

                sizeof(has_stable_iterators_tester(t))==sizeof(yes_type) ) );

#else  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

        public:

#    if BOOST_WORKAROUND( __IBMCPP__, <= 600 )

            enum { value = false };

#    else

            BOOST_STATIC_CONSTANT(bool, value=false);

#    endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )

#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION



            typedef mpl::bool_<has_stable_iterators<T>::value> type;

        };





        //! Const time insert trait

        /*!

            This trait specifies that the sequence's insert method has

            constant time complexity.

        */

        template< typename T >

        class has_const_time_insert

        {

#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

        private:

            static T* t;

        public:

            BOOST_STATIC_CONSTANT(bool, value=(

                sizeof(has_const_time_insert_tester(t))==sizeof(yes_type) ) );

#else  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

        public:

#    if BOOST_WORKAROUND( __IBMCPP__, <= 600 )

            enum { value = false };

#    else

            BOOST_STATIC_CONSTANT(bool, value=false);

#    endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )

#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION



            typedef mpl::bool_<has_const_time_insert<T>::value> type;

        };





        //! Const time erase trait

        /*!

            This trait specifies that the sequence's erase method has

            constant time complexity.

        */

        template< typename T >

        class has_const_time_erase

        {

#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

        private:

            static T* t;

        public:

            BOOST_STATIC_CONSTANT(bool, value=(

                sizeof(has_const_time_erase_tester(t))==sizeof(yes_type) ) );

#else  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

        public:

#    if BOOST_WORKAROUND( __IBMCPP__, <= 600 )

            enum { value = false };

#    else

            BOOST_STATIC_CONSTANT(bool, value=false);

#    endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )

#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION



            typedef mpl::bool_<has_const_time_erase<T>::value> type;

        };



    } // namespace algorithm

} // namespace boost





#endif  // BOOST_STRING_SEQUENCE_TRAITS_HPP

