boost_algorithm/include/boost/algorithm/string/sequence_traits.hpp

//  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