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