diff options
Diffstat (limited to 'contrib/src/boost/algorithm/string/detail')
13 files changed, 2524 insertions, 2524 deletions
diff --git a/contrib/src/boost/algorithm/string/detail/case_conv.hpp b/contrib/src/boost/algorithm/string/detail/case_conv.hpp index bc0891d..42621c7 100644 --- a/contrib/src/boost/algorithm/string/detail/case_conv.hpp +++ b/contrib/src/boost/algorithm/string/detail/case_conv.hpp @@ -1,123 +1,123 @@ -// Boost string_algo library string_funct.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_CASE_CONV_DETAIL_HPP
-#define BOOST_STRING_CASE_CONV_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <locale>
-#include <functional>
-
-#include <boost/type_traits/make_unsigned.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// case conversion functors -----------------------------------------------//
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
-
- // a tolower functor
- template<typename CharT>
- struct to_lowerF : public std::unary_function<CharT, CharT>
- {
- // Constructor
- to_lowerF( const std::locale& Loc ) : m_Loc( &Loc ) {}
-
- // Operation
- CharT operator ()( CharT Ch ) const
- {
- #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
- return std::tolower( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch ));
- #else
- return std::tolower<CharT>( Ch, *m_Loc );
- #endif
- }
- private:
- const std::locale* m_Loc;
- };
-
- // a toupper functor
- template<typename CharT>
- struct to_upperF : public std::unary_function<CharT, CharT>
- {
- // Constructor
- to_upperF( const std::locale& Loc ) : m_Loc( &Loc ) {}
-
- // Operation
- CharT operator ()( CharT Ch ) const
- {
- #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
- return std::toupper( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch ));
- #else
- return std::toupper<CharT>( Ch, *m_Loc );
- #endif
- }
- private:
- const std::locale* m_Loc;
- };
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
-
-// algorithm implementation -------------------------------------------------------------------------
-
- // Transform a range
- template<typename OutputIteratorT, typename RangeT, typename FunctorT>
- OutputIteratorT transform_range_copy(
- OutputIteratorT Output,
- const RangeT& Input,
- FunctorT Functor)
- {
- return std::transform(
- ::boost::begin(Input),
- ::boost::end(Input),
- Output,
- Functor);
- }
-
- // Transform a range (in-place)
- template<typename RangeT, typename FunctorT>
- void transform_range(
- const RangeT& Input,
- FunctorT Functor)
- {
- std::transform(
- ::boost::begin(Input),
- ::boost::end(Input),
- ::boost::begin(Input),
- Functor);
- }
-
- template<typename SequenceT, typename RangeT, typename FunctorT>
- inline SequenceT transform_range_copy(
- const RangeT& Input,
- FunctorT Functor)
- {
- return SequenceT(
- ::boost::make_transform_iterator(
- ::boost::begin(Input),
- Functor),
- ::boost::make_transform_iterator(
- ::boost::end(Input),
- Functor));
- }
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_CASE_CONV_DETAIL_HPP
+// Boost string_algo library string_funct.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_CASE_CONV_DETAIL_HPP +#define BOOST_STRING_CASE_CONV_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <locale> +#include <functional> + +#include <boost/type_traits/make_unsigned.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// case conversion functors -----------------------------------------------// + +#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) +#pragma warning(push) +#pragma warning(disable:4512) //assignment operator could not be generated +#endif + + // a tolower functor + template<typename CharT> + struct to_lowerF : public std::unary_function<CharT, CharT> + { + // Constructor + to_lowerF( const std::locale& Loc ) : m_Loc( &Loc ) {} + + // Operation + CharT operator ()( CharT Ch ) const + { + #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL) + return std::tolower( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch )); + #else + return std::tolower<CharT>( Ch, *m_Loc ); + #endif + } + private: + const std::locale* m_Loc; + }; + + // a toupper functor + template<typename CharT> + struct to_upperF : public std::unary_function<CharT, CharT> + { + // Constructor + to_upperF( const std::locale& Loc ) : m_Loc( &Loc ) {} + + // Operation + CharT operator ()( CharT Ch ) const + { + #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL) + return std::toupper( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch )); + #else + return std::toupper<CharT>( Ch, *m_Loc ); + #endif + } + private: + const std::locale* m_Loc; + }; + +#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) +#pragma warning(pop) +#endif + +// algorithm implementation ------------------------------------------------------------------------- + + // Transform a range + template<typename OutputIteratorT, typename RangeT, typename FunctorT> + OutputIteratorT transform_range_copy( + OutputIteratorT Output, + const RangeT& Input, + FunctorT Functor) + { + return std::transform( + ::boost::begin(Input), + ::boost::end(Input), + Output, + Functor); + } + + // Transform a range (in-place) + template<typename RangeT, typename FunctorT> + void transform_range( + const RangeT& Input, + FunctorT Functor) + { + std::transform( + ::boost::begin(Input), + ::boost::end(Input), + ::boost::begin(Input), + Functor); + } + + template<typename SequenceT, typename RangeT, typename FunctorT> + inline SequenceT transform_range_copy( + const RangeT& Input, + FunctorT Functor) + { + return SequenceT( + ::boost::make_transform_iterator( + ::boost::begin(Input), + Functor), + ::boost::make_transform_iterator( + ::boost::end(Input), + Functor)); + } + + } // namespace detail + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_CASE_CONV_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/classification.hpp b/contrib/src/boost/algorithm/string/detail/classification.hpp index 7fe9d58..704d9d2 100644 --- a/contrib/src/boost/algorithm/string/detail/classification.hpp +++ b/contrib/src/boost/algorithm/string/detail/classification.hpp @@ -1,353 +1,353 @@ -// Boost string_algo library classification.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_CLASSIFICATION_DETAIL_HPP
-#define BOOST_STRING_CLASSIFICATION_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <algorithm>
-#include <functional>
-#include <locale>
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-#include <boost/algorithm/string/predicate_facade.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// classification functors -----------------------------------------------//
-
- // is_classified functor
- struct is_classifiedF :
- public predicate_facade<is_classifiedF>
- {
- // Boost.ResultOf support
- typedef bool result_type;
-
- // Constructor from a locale
- is_classifiedF(std::ctype_base::mask Type, std::locale const & Loc = std::locale()) :
- m_Type(Type), m_Locale(Loc) {}
- // Operation
- template<typename CharT>
- bool operator()( CharT Ch ) const
- {
- return std::use_facet< std::ctype<CharT> >(m_Locale).is( m_Type, Ch );
- }
-
- #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x582) && !defined(_USE_OLD_RW_STL)
- template<>
- bool operator()( char const Ch ) const
- {
- return std::use_facet< std::ctype<char> >(m_Locale).is( m_Type, Ch );
- }
- #endif
-
- private:
- std::ctype_base::mask m_Type;
- std::locale m_Locale;
- };
-
-
- // is_any_of functor
- /*
- returns true if the value is from the specified set
- */
- template<typename CharT>
- struct is_any_ofF :
- public predicate_facade<is_any_ofF<CharT> >
- {
- private:
- // set cannot operate on const value-type
- typedef typename ::boost::remove_const<CharT>::type set_value_type;
-
- public:
- // Boost.ResultOf support
- typedef bool result_type;
-
- // Constructor
- template<typename RangeT>
- is_any_ofF( const RangeT& Range ) : m_Size(0)
- {
- // Prepare storage
- m_Storage.m_dynSet=0;
-
- std::size_t Size=::boost::distance(Range);
- m_Size=Size;
- set_value_type* Storage=0;
-
- if(use_fixed_storage(m_Size))
- {
- // Use fixed storage
- Storage=&m_Storage.m_fixSet[0];
- }
- else
- {
- // Use dynamic storage
- m_Storage.m_dynSet=new set_value_type[m_Size];
- Storage=m_Storage.m_dynSet;
- }
-
- // Use fixed storage
- ::std::copy(::boost::begin(Range), ::boost::end(Range), Storage);
- ::std::sort(Storage, Storage+m_Size);
- }
-
- // Copy constructor
- is_any_ofF(const is_any_ofF& Other) : m_Size(Other.m_Size)
- {
- // Prepare storage
- m_Storage.m_dynSet=0;
- const set_value_type* SrcStorage=0;
- set_value_type* DestStorage=0;
-
- if(use_fixed_storage(m_Size))
- {
- // Use fixed storage
- DestStorage=&m_Storage.m_fixSet[0];
- SrcStorage=&Other.m_Storage.m_fixSet[0];
- }
- else
- {
- // Use dynamic storage
- m_Storage.m_dynSet=new set_value_type[m_Size];
- DestStorage=m_Storage.m_dynSet;
- SrcStorage=Other.m_Storage.m_dynSet;
- }
-
- // Use fixed storage
- ::std::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
- }
-
- // Destructor
- ~is_any_ofF()
- {
- if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
- {
- delete [] m_Storage.m_dynSet;
- }
- }
-
- // Assignment
- is_any_ofF& operator=(const is_any_ofF& Other)
- {
- // Handle self assignment
- if(this==&Other) return *this;
-
- // Prepare storage
- const set_value_type* SrcStorage;
- set_value_type* DestStorage;
-
- if(use_fixed_storage(Other.m_Size))
- {
- // Use fixed storage
- DestStorage=&m_Storage.m_fixSet[0];
- SrcStorage=&Other.m_Storage.m_fixSet[0];
-
- // Delete old storage if was present
- if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
- {
- delete [] m_Storage.m_dynSet;
- }
-
- // Set new size
- m_Size=Other.m_Size;
- }
- else
- {
- // Other uses dynamic storage
- SrcStorage=Other.m_Storage.m_dynSet;
-
- // Check what kind of storage are we using right now
- if(use_fixed_storage(m_Size))
- {
- // Using fixed storage, allocate new
- set_value_type* pTemp=new set_value_type[Other.m_Size];
- DestStorage=pTemp;
- m_Storage.m_dynSet=pTemp;
- m_Size=Other.m_Size;
- }
- else
- {
- // Using dynamic storage, check if can reuse
- if(m_Storage.m_dynSet!=0 && m_Size>=Other.m_Size && m_Size<Other.m_Size*2)
- {
- // Reuse the current storage
- DestStorage=m_Storage.m_dynSet;
- m_Size=Other.m_Size;
- }
- else
- {
- // Allocate the new one
- set_value_type* pTemp=new set_value_type[Other.m_Size];
- DestStorage=pTemp;
-
- // Delete old storage if necessary
- if(m_Storage.m_dynSet!=0)
- {
- delete [] m_Storage.m_dynSet;
- }
- // Store the new storage
- m_Storage.m_dynSet=pTemp;
- // Set new size
- m_Size=Other.m_Size;
- }
- }
- }
-
- // Copy the data
- ::std::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
-
- return *this;
- }
-
- // Operation
- template<typename Char2T>
- bool operator()( Char2T Ch ) const
- {
- const set_value_type* Storage=
- (use_fixed_storage(m_Size))
- ? &m_Storage.m_fixSet[0]
- : m_Storage.m_dynSet;
-
- return ::std::binary_search(Storage, Storage+m_Size, Ch);
- }
- private:
- // check if the size is eligible for fixed storage
- static bool use_fixed_storage(std::size_t size)
- {
- return size<=sizeof(set_value_type*)*2;
- }
-
-
- private:
- // storage
- // The actual used storage is selected on the type
- union
- {
- set_value_type* m_dynSet;
- set_value_type m_fixSet[sizeof(set_value_type*)*2];
- }
- m_Storage;
-
- // storage size
- ::std::size_t m_Size;
- };
-
- // is_from_range functor
- /*
- returns true if the value is from the specified range.
- (i.e. x>=From && x>=To)
- */
- template<typename CharT>
- struct is_from_rangeF :
- public predicate_facade< is_from_rangeF<CharT> >
- {
- // Boost.ResultOf support
- typedef bool result_type;
-
- // Constructor
- is_from_rangeF( CharT From, CharT To ) : m_From(From), m_To(To) {}
-
- // Operation
- template<typename Char2T>
- bool operator()( Char2T Ch ) const
- {
- return ( m_From <= Ch ) && ( Ch <= m_To );
- }
-
- private:
- CharT m_From;
- CharT m_To;
- };
-
- // class_and composition predicate
- template<typename Pred1T, typename Pred2T>
- struct pred_andF :
- public predicate_facade< pred_andF<Pred1T,Pred2T> >
- {
- public:
-
- // Boost.ResultOf support
- typedef bool result_type;
-
- // Constructor
- pred_andF( Pred1T Pred1, Pred2T Pred2 ) :
- m_Pred1(Pred1), m_Pred2(Pred2) {}
-
- // Operation
- template<typename CharT>
- bool operator()( CharT Ch ) const
- {
- return m_Pred1(Ch) && m_Pred2(Ch);
- }
-
- private:
- Pred1T m_Pred1;
- Pred2T m_Pred2;
- };
-
- // class_or composition predicate
- template<typename Pred1T, typename Pred2T>
- struct pred_orF :
- public predicate_facade< pred_orF<Pred1T,Pred2T> >
- {
- public:
- // Boost.ResultOf support
- typedef bool result_type;
-
- // Constructor
- pred_orF( Pred1T Pred1, Pred2T Pred2 ) :
- m_Pred1(Pred1), m_Pred2(Pred2) {}
-
- // Operation
- template<typename CharT>
- bool operator()( CharT Ch ) const
- {
- return m_Pred1(Ch) || m_Pred2(Ch);
- }
-
- private:
- Pred1T m_Pred1;
- Pred2T m_Pred2;
- };
-
- // class_not composition predicate
- template< typename PredT >
- struct pred_notF :
- public predicate_facade< pred_notF<PredT> >
- {
- public:
- // Boost.ResultOf support
- typedef bool result_type;
-
- // Constructor
- pred_notF( PredT Pred ) : m_Pred(Pred) {}
-
- // Operation
- template<typename CharT>
- bool operator()( CharT Ch ) const
- {
- return !m_Pred(Ch);
- }
-
- private:
- PredT m_Pred;
- };
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_CLASSIFICATION_DETAIL_HPP
+// Boost string_algo library classification.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_CLASSIFICATION_DETAIL_HPP +#define BOOST_STRING_CLASSIFICATION_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <algorithm> +#include <functional> +#include <locale> + +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> + +#include <boost/algorithm/string/predicate_facade.hpp> +#include <boost/type_traits/remove_const.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// classification functors -----------------------------------------------// + + // is_classified functor + struct is_classifiedF : + public predicate_facade<is_classifiedF> + { + // Boost.ResultOf support + typedef bool result_type; + + // Constructor from a locale + is_classifiedF(std::ctype_base::mask Type, std::locale const & Loc = std::locale()) : + m_Type(Type), m_Locale(Loc) {} + // Operation + template<typename CharT> + bool operator()( CharT Ch ) const + { + return std::use_facet< std::ctype<CharT> >(m_Locale).is( m_Type, Ch ); + } + + #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x582) && !defined(_USE_OLD_RW_STL) + template<> + bool operator()( char const Ch ) const + { + return std::use_facet< std::ctype<char> >(m_Locale).is( m_Type, Ch ); + } + #endif + + private: + std::ctype_base::mask m_Type; + std::locale m_Locale; + }; + + + // is_any_of functor + /* + returns true if the value is from the specified set + */ + template<typename CharT> + struct is_any_ofF : + public predicate_facade<is_any_ofF<CharT> > + { + private: + // set cannot operate on const value-type + typedef typename ::boost::remove_const<CharT>::type set_value_type; + + public: + // Boost.ResultOf support + typedef bool result_type; + + // Constructor + template<typename RangeT> + is_any_ofF( const RangeT& Range ) : m_Size(0) + { + // Prepare storage + m_Storage.m_dynSet=0; + + std::size_t Size=::boost::distance(Range); + m_Size=Size; + set_value_type* Storage=0; + + if(use_fixed_storage(m_Size)) + { + // Use fixed storage + Storage=&m_Storage.m_fixSet[0]; + } + else + { + // Use dynamic storage + m_Storage.m_dynSet=new set_value_type[m_Size]; + Storage=m_Storage.m_dynSet; + } + + // Use fixed storage + ::std::copy(::boost::begin(Range), ::boost::end(Range), Storage); + ::std::sort(Storage, Storage+m_Size); + } + + // Copy constructor + is_any_ofF(const is_any_ofF& Other) : m_Size(Other.m_Size) + { + // Prepare storage + m_Storage.m_dynSet=0; + const set_value_type* SrcStorage=0; + set_value_type* DestStorage=0; + + if(use_fixed_storage(m_Size)) + { + // Use fixed storage + DestStorage=&m_Storage.m_fixSet[0]; + SrcStorage=&Other.m_Storage.m_fixSet[0]; + } + else + { + // Use dynamic storage + m_Storage.m_dynSet=new set_value_type[m_Size]; + DestStorage=m_Storage.m_dynSet; + SrcStorage=Other.m_Storage.m_dynSet; + } + + // Use fixed storage + ::std::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size); + } + + // Destructor + ~is_any_ofF() + { + if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0) + { + delete [] m_Storage.m_dynSet; + } + } + + // Assignment + is_any_ofF& operator=(const is_any_ofF& Other) + { + // Handle self assignment + if(this==&Other) return *this; + + // Prepare storage + const set_value_type* SrcStorage; + set_value_type* DestStorage; + + if(use_fixed_storage(Other.m_Size)) + { + // Use fixed storage + DestStorage=&m_Storage.m_fixSet[0]; + SrcStorage=&Other.m_Storage.m_fixSet[0]; + + // Delete old storage if was present + if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0) + { + delete [] m_Storage.m_dynSet; + } + + // Set new size + m_Size=Other.m_Size; + } + else + { + // Other uses dynamic storage + SrcStorage=Other.m_Storage.m_dynSet; + + // Check what kind of storage are we using right now + if(use_fixed_storage(m_Size)) + { + // Using fixed storage, allocate new + set_value_type* pTemp=new set_value_type[Other.m_Size]; + DestStorage=pTemp; + m_Storage.m_dynSet=pTemp; + m_Size=Other.m_Size; + } + else + { + // Using dynamic storage, check if can reuse + if(m_Storage.m_dynSet!=0 && m_Size>=Other.m_Size && m_Size<Other.m_Size*2) + { + // Reuse the current storage + DestStorage=m_Storage.m_dynSet; + m_Size=Other.m_Size; + } + else + { + // Allocate the new one + set_value_type* pTemp=new set_value_type[Other.m_Size]; + DestStorage=pTemp; + + // Delete old storage if necessary + if(m_Storage.m_dynSet!=0) + { + delete [] m_Storage.m_dynSet; + } + // Store the new storage + m_Storage.m_dynSet=pTemp; + // Set new size + m_Size=Other.m_Size; + } + } + } + + // Copy the data + ::std::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size); + + return *this; + } + + // Operation + template<typename Char2T> + bool operator()( Char2T Ch ) const + { + const set_value_type* Storage= + (use_fixed_storage(m_Size)) + ? &m_Storage.m_fixSet[0] + : m_Storage.m_dynSet; + + return ::std::binary_search(Storage, Storage+m_Size, Ch); + } + private: + // check if the size is eligible for fixed storage + static bool use_fixed_storage(std::size_t size) + { + return size<=sizeof(set_value_type*)*2; + } + + + private: + // storage + // The actual used storage is selected on the type + union + { + set_value_type* m_dynSet; + set_value_type m_fixSet[sizeof(set_value_type*)*2]; + } + m_Storage; + + // storage size + ::std::size_t m_Size; + }; + + // is_from_range functor + /* + returns true if the value is from the specified range. + (i.e. x>=From && x>=To) + */ + template<typename CharT> + struct is_from_rangeF : + public predicate_facade< is_from_rangeF<CharT> > + { + // Boost.ResultOf support + typedef bool result_type; + + // Constructor + is_from_rangeF( CharT From, CharT To ) : m_From(From), m_To(To) {} + + // Operation + template<typename Char2T> + bool operator()( Char2T Ch ) const + { + return ( m_From <= Ch ) && ( Ch <= m_To ); + } + + private: + CharT m_From; + CharT m_To; + }; + + // class_and composition predicate + template<typename Pred1T, typename Pred2T> + struct pred_andF : + public predicate_facade< pred_andF<Pred1T,Pred2T> > + { + public: + + // Boost.ResultOf support + typedef bool result_type; + + // Constructor + pred_andF( Pred1T Pred1, Pred2T Pred2 ) : + m_Pred1(Pred1), m_Pred2(Pred2) {} + + // Operation + template<typename CharT> + bool operator()( CharT Ch ) const + { + return m_Pred1(Ch) && m_Pred2(Ch); + } + + private: + Pred1T m_Pred1; + Pred2T m_Pred2; + }; + + // class_or composition predicate + template<typename Pred1T, typename Pred2T> + struct pred_orF : + public predicate_facade< pred_orF<Pred1T,Pred2T> > + { + public: + // Boost.ResultOf support + typedef bool result_type; + + // Constructor + pred_orF( Pred1T Pred1, Pred2T Pred2 ) : + m_Pred1(Pred1), m_Pred2(Pred2) {} + + // Operation + template<typename CharT> + bool operator()( CharT Ch ) const + { + return m_Pred1(Ch) || m_Pred2(Ch); + } + + private: + Pred1T m_Pred1; + Pred2T m_Pred2; + }; + + // class_not composition predicate + template< typename PredT > + struct pred_notF : + public predicate_facade< pred_notF<PredT> > + { + public: + // Boost.ResultOf support + typedef bool result_type; + + // Constructor + pred_notF( PredT Pred ) : m_Pred(Pred) {} + + // Operation + template<typename CharT> + bool operator()( CharT Ch ) const + { + return !m_Pred(Ch); + } + + private: + PredT m_Pred; + }; + + } // namespace detail + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_CLASSIFICATION_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/find_format.hpp b/contrib/src/boost/algorithm/string/detail/find_format.hpp index b9b495d..b398750 100644 --- a/contrib/src/boost/algorithm/string/detail/find_format.hpp +++ b/contrib/src/boost/algorithm/string/detail/find_format.hpp @@ -1,204 +1,204 @@ -// Boost string_algo library find_format.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_FIND_FORMAT_DETAIL_HPP
-#define BOOST_STRING_FIND_FORMAT_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/range/const_iterator.hpp>
-#include <boost/range/iterator.hpp>
-#include <boost/algorithm/string/detail/find_format_store.hpp>
-#include <boost/algorithm/string/detail/replace_storage.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// find_format_copy (iterator variant) implementation -------------------------------//
-
- template<
- typename OutputIteratorT,
- typename InputT,
- typename FormatterT,
- typename FindResultT,
- typename FormatResultT >
- inline OutputIteratorT find_format_copy_impl2(
- OutputIteratorT Output,
- const InputT& Input,
- FormatterT Formatter,
- const FindResultT& FindResult,
- const FormatResultT& FormatResult )
- {
- typedef find_format_store<
- BOOST_STRING_TYPENAME
- range_const_iterator<InputT>::type,
- FormatterT,
- FormatResultT > store_type;
-
- // Create store for the find result
- store_type M( FindResult, FormatResult, Formatter );
-
- if ( !M )
- {
- // Match not found - return original sequence
- Output = std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
- return Output;
- }
-
- // Copy the beginning of the sequence
- Output = std::copy( ::boost::begin(Input), ::boost::begin(M), Output );
- // Format find result
- // Copy formatted result
- Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
- // Copy the rest of the sequence
- Output = std::copy( M.end(), ::boost::end(Input), Output );
-
- return Output;
- }
-
- template<
- typename OutputIteratorT,
- typename InputT,
- typename FormatterT,
- typename FindResultT >
- inline OutputIteratorT find_format_copy_impl(
- OutputIteratorT Output,
- const InputT& Input,
- FormatterT Formatter,
- const FindResultT& FindResult )
- {
- if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
- return ::boost::algorithm::detail::find_format_copy_impl2(
- Output,
- Input,
- Formatter,
- FindResult,
- Formatter(FindResult) );
- } else {
- return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
- }
- }
-
-
-// find_format_copy implementation --------------------------------------------------//
-
- template<
- typename InputT,
- typename FormatterT,
- typename FindResultT,
- typename FormatResultT >
- inline InputT find_format_copy_impl2(
- const InputT& Input,
- FormatterT Formatter,
- const FindResultT& FindResult,
- const FormatResultT& FormatResult)
- {
- typedef find_format_store<
- BOOST_STRING_TYPENAME
- range_const_iterator<InputT>::type,
- FormatterT,
- FormatResultT > store_type;
-
- // Create store for the find result
- store_type M( FindResult, FormatResult, Formatter );
-
- if ( !M )
- {
- // Match not found - return original sequence
- return InputT( Input );
- }
-
- InputT Output;
- // Copy the beginning of the sequence
- boost::algorithm::detail::insert( Output, ::boost::end(Output), ::boost::begin(Input), M.begin() );
- // Copy formatted result
- boost::algorithm::detail::insert( Output, ::boost::end(Output), M.format_result() );
- // Copy the rest of the sequence
- boost::algorithm::detail::insert( Output, ::boost::end(Output), M.end(), ::boost::end(Input) );
-
- return Output;
- }
-
- template<
- typename InputT,
- typename FormatterT,
- typename FindResultT >
- inline InputT find_format_copy_impl(
- const InputT& Input,
- FormatterT Formatter,
- const FindResultT& FindResult)
- {
- if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
- return ::boost::algorithm::detail::find_format_copy_impl2(
- Input,
- Formatter,
- FindResult,
- Formatter(FindResult) );
- } else {
- return Input;
- }
- }
-
- // replace implementation ----------------------------------------------------//
-
- template<
- typename InputT,
- typename FormatterT,
- typename FindResultT,
- typename FormatResultT >
- inline void find_format_impl2(
- InputT& Input,
- FormatterT Formatter,
- const FindResultT& FindResult,
- const FormatResultT& FormatResult)
- {
- typedef find_format_store<
- BOOST_STRING_TYPENAME
- range_iterator<InputT>::type,
- FormatterT,
- FormatResultT > store_type;
-
- // Create store for the find result
- store_type M( FindResult, FormatResult, Formatter );
-
- if ( !M )
- {
- // Search not found - return original sequence
- return;
- }
-
- // Replace match
- ::boost::algorithm::detail::replace( Input, M.begin(), M.end(), M.format_result() );
- }
-
- template<
- typename InputT,
- typename FormatterT,
- typename FindResultT >
- inline void find_format_impl(
- InputT& Input,
- FormatterT Formatter,
- const FindResultT& FindResult)
- {
- if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
- ::boost::algorithm::detail::find_format_impl2(
- Input,
- Formatter,
- FindResult,
- Formatter(FindResult) );
- }
- }
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-#endif // BOOST_STRING_FIND_FORMAT_DETAIL_HPP
+// Boost string_algo library find_format.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_FIND_FORMAT_DETAIL_HPP +#define BOOST_STRING_FIND_FORMAT_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <boost/range/iterator_range_core.hpp> +#include <boost/range/const_iterator.hpp> +#include <boost/range/iterator.hpp> +#include <boost/algorithm/string/detail/find_format_store.hpp> +#include <boost/algorithm/string/detail/replace_storage.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// find_format_copy (iterator variant) implementation -------------------------------// + + template< + typename OutputIteratorT, + typename InputT, + typename FormatterT, + typename FindResultT, + typename FormatResultT > + inline OutputIteratorT find_format_copy_impl2( + OutputIteratorT Output, + const InputT& Input, + FormatterT Formatter, + const FindResultT& FindResult, + const FormatResultT& FormatResult ) + { + typedef find_format_store< + BOOST_STRING_TYPENAME + range_const_iterator<InputT>::type, + FormatterT, + FormatResultT > store_type; + + // Create store for the find result + store_type M( FindResult, FormatResult, Formatter ); + + if ( !M ) + { + // Match not found - return original sequence + Output = std::copy( ::boost::begin(Input), ::boost::end(Input), Output ); + return Output; + } + + // Copy the beginning of the sequence + Output = std::copy( ::boost::begin(Input), ::boost::begin(M), Output ); + // Format find result + // Copy formatted result + Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output ); + // Copy the rest of the sequence + Output = std::copy( M.end(), ::boost::end(Input), Output ); + + return Output; + } + + template< + typename OutputIteratorT, + typename InputT, + typename FormatterT, + typename FindResultT > + inline OutputIteratorT find_format_copy_impl( + OutputIteratorT Output, + const InputT& Input, + FormatterT Formatter, + const FindResultT& FindResult ) + { + if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) { + return ::boost::algorithm::detail::find_format_copy_impl2( + Output, + Input, + Formatter, + FindResult, + Formatter(FindResult) ); + } else { + return std::copy( ::boost::begin(Input), ::boost::end(Input), Output ); + } + } + + +// find_format_copy implementation --------------------------------------------------// + + template< + typename InputT, + typename FormatterT, + typename FindResultT, + typename FormatResultT > + inline InputT find_format_copy_impl2( + const InputT& Input, + FormatterT Formatter, + const FindResultT& FindResult, + const FormatResultT& FormatResult) + { + typedef find_format_store< + BOOST_STRING_TYPENAME + range_const_iterator<InputT>::type, + FormatterT, + FormatResultT > store_type; + + // Create store for the find result + store_type M( FindResult, FormatResult, Formatter ); + + if ( !M ) + { + // Match not found - return original sequence + return InputT( Input ); + } + + InputT Output; + // Copy the beginning of the sequence + boost::algorithm::detail::insert( Output, ::boost::end(Output), ::boost::begin(Input), M.begin() ); + // Copy formatted result + boost::algorithm::detail::insert( Output, ::boost::end(Output), M.format_result() ); + // Copy the rest of the sequence + boost::algorithm::detail::insert( Output, ::boost::end(Output), M.end(), ::boost::end(Input) ); + + return Output; + } + + template< + typename InputT, + typename FormatterT, + typename FindResultT > + inline InputT find_format_copy_impl( + const InputT& Input, + FormatterT Formatter, + const FindResultT& FindResult) + { + if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) { + return ::boost::algorithm::detail::find_format_copy_impl2( + Input, + Formatter, + FindResult, + Formatter(FindResult) ); + } else { + return Input; + } + } + + // replace implementation ----------------------------------------------------// + + template< + typename InputT, + typename FormatterT, + typename FindResultT, + typename FormatResultT > + inline void find_format_impl2( + InputT& Input, + FormatterT Formatter, + const FindResultT& FindResult, + const FormatResultT& FormatResult) + { + typedef find_format_store< + BOOST_STRING_TYPENAME + range_iterator<InputT>::type, + FormatterT, + FormatResultT > store_type; + + // Create store for the find result + store_type M( FindResult, FormatResult, Formatter ); + + if ( !M ) + { + // Search not found - return original sequence + return; + } + + // Replace match + ::boost::algorithm::detail::replace( Input, M.begin(), M.end(), M.format_result() ); + } + + template< + typename InputT, + typename FormatterT, + typename FindResultT > + inline void find_format_impl( + InputT& Input, + FormatterT Formatter, + const FindResultT& FindResult) + { + if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) { + ::boost::algorithm::detail::find_format_impl2( + Input, + Formatter, + FindResult, + Formatter(FindResult) ); + } + } + + } // namespace detail + } // namespace algorithm +} // namespace boost + +#endif // BOOST_STRING_FIND_FORMAT_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/find_format_all.hpp b/contrib/src/boost/algorithm/string/detail/find_format_all.hpp index ae1e5da..52930c8 100644 --- a/contrib/src/boost/algorithm/string/detail/find_format_all.hpp +++ b/contrib/src/boost/algorithm/string/detail/find_format_all.hpp @@ -1,273 +1,273 @@ -// Boost string_algo library find_format_all.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_FIND_FORMAT_ALL_DETAIL_HPP
-#define BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/range/const_iterator.hpp>
-#include <boost/range/value_type.hpp>
-#include <boost/algorithm/string/detail/find_format_store.hpp>
-#include <boost/algorithm/string/detail/replace_storage.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// find_format_all_copy (iterator variant) implementation ---------------------------//
-
- template<
- typename OutputIteratorT,
- typename InputT,
- typename FinderT,
- typename FormatterT,
- typename FindResultT,
- typename FormatResultT >
- inline OutputIteratorT find_format_all_copy_impl2(
- OutputIteratorT Output,
- const InputT& Input,
- FinderT Finder,
- FormatterT Formatter,
- const FindResultT& FindResult,
- const FormatResultT& FormatResult )
- {
- typedef BOOST_STRING_TYPENAME
- range_const_iterator<InputT>::type input_iterator_type;
-
- typedef find_format_store<
- input_iterator_type,
- FormatterT,
- FormatResultT > store_type;
-
- // Create store for the find result
- store_type M( FindResult, FormatResult, Formatter );
-
- // Initialize last match
- input_iterator_type LastMatch=::boost::begin(Input);
-
- // Iterate through all matches
- while( M )
- {
- // Copy the beginning of the sequence
- Output = std::copy( LastMatch, M.begin(), Output );
- // Copy formatted result
- Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
-
- // Proceed to the next match
- LastMatch=M.end();
- M=Finder( LastMatch, ::boost::end(Input) );
- }
-
- // Copy the rest of the sequence
- Output = std::copy( LastMatch, ::boost::end(Input), Output );
-
- return Output;
- }
-
- template<
- typename OutputIteratorT,
- typename InputT,
- typename FinderT,
- typename FormatterT,
- typename FindResultT >
- inline OutputIteratorT find_format_all_copy_impl(
- OutputIteratorT Output,
- const InputT& Input,
- FinderT Finder,
- FormatterT Formatter,
- const FindResultT& FindResult )
- {
- if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
- return ::boost::algorithm::detail::find_format_all_copy_impl2(
- Output,
- Input,
- Finder,
- Formatter,
- FindResult,
- Formatter(FindResult) );
- } else {
- return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
- }
- }
-
- // find_format_all_copy implementation ----------------------------------------------//
-
- template<
- typename InputT,
- typename FinderT,
- typename FormatterT,
- typename FindResultT,
- typename FormatResultT >
- inline InputT find_format_all_copy_impl2(
- const InputT& Input,
- FinderT Finder,
- FormatterT Formatter,
- const FindResultT& FindResult,
- const FormatResultT& FormatResult)
- {
- typedef BOOST_STRING_TYPENAME
- range_const_iterator<InputT>::type input_iterator_type;
-
- typedef find_format_store<
- input_iterator_type,
- FormatterT,
- FormatResultT > store_type;
-
- // Create store for the find result
- store_type M( FindResult, FormatResult, Formatter );
-
- // Initialize last match
- input_iterator_type LastMatch=::boost::begin(Input);
-
- // Output temporary
- InputT Output;
-
- // Iterate through all matches
- while( M )
- {
- // Copy the beginning of the sequence
- boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, M.begin() );
- // Copy formatted result
- boost::algorithm::detail::insert( Output, ::boost::end(Output), M.format_result() );
-
- // Proceed to the next match
- LastMatch=M.end();
- M=Finder( LastMatch, ::boost::end(Input) );
- }
-
- // Copy the rest of the sequence
- ::boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, ::boost::end(Input) );
-
- return Output;
- }
-
- template<
- typename InputT,
- typename FinderT,
- typename FormatterT,
- typename FindResultT >
- inline InputT find_format_all_copy_impl(
- const InputT& Input,
- FinderT Finder,
- FormatterT Formatter,
- const FindResultT& FindResult)
- {
- if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
- return ::boost::algorithm::detail::find_format_all_copy_impl2(
- Input,
- Finder,
- Formatter,
- FindResult,
- Formatter(FindResult) );
- } else {
- return Input;
- }
- }
-
- // find_format_all implementation ------------------------------------------------//
-
- template<
- typename InputT,
- typename FinderT,
- typename FormatterT,
- typename FindResultT,
- typename FormatResultT >
- inline void find_format_all_impl2(
- InputT& Input,
- FinderT Finder,
- FormatterT Formatter,
- FindResultT FindResult,
- FormatResultT FormatResult)
- {
- typedef BOOST_STRING_TYPENAME
- range_iterator<InputT>::type input_iterator_type;
- typedef find_format_store<
- input_iterator_type,
- FormatterT,
- FormatResultT > store_type;
-
- // Create store for the find result
- store_type M( FindResult, FormatResult, Formatter );
-
- // Instantiate replacement storage
- std::deque<
- BOOST_STRING_TYPENAME range_value<InputT>::type> Storage;
-
- // Initialize replacement iterators
- input_iterator_type InsertIt=::boost::begin(Input);
- input_iterator_type SearchIt=::boost::begin(Input);
-
- while( M )
- {
- // process the segment
- InsertIt=process_segment(
- Storage,
- Input,
- InsertIt,
- SearchIt,
- M.begin() );
-
- // Adjust search iterator
- SearchIt=M.end();
-
- // Copy formatted replace to the storage
- ::boost::algorithm::detail::copy_to_storage( Storage, M.format_result() );
-
- // Find range for a next match
- M=Finder( SearchIt, ::boost::end(Input) );
- }
-
- // process the last segment
- InsertIt=::boost::algorithm::detail::process_segment(
- Storage,
- Input,
- InsertIt,
- SearchIt,
- ::boost::end(Input) );
-
- if ( Storage.empty() )
- {
- // Truncate input
- ::boost::algorithm::detail::erase( Input, InsertIt, ::boost::end(Input) );
- }
- else
- {
- // Copy remaining data to the end of input
- ::boost::algorithm::detail::insert( Input, ::boost::end(Input), Storage.begin(), Storage.end() );
- }
- }
-
- template<
- typename InputT,
- typename FinderT,
- typename FormatterT,
- typename FindResultT >
- inline void find_format_all_impl(
- InputT& Input,
- FinderT Finder,
- FormatterT Formatter,
- FindResultT FindResult)
- {
- if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
- ::boost::algorithm::detail::find_format_all_impl2(
- Input,
- Finder,
- Formatter,
- FindResult,
- Formatter(FindResult) );
- }
- }
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-#endif // BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP
+// Boost string_algo library find_format_all.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_FIND_FORMAT_ALL_DETAIL_HPP +#define BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <boost/range/iterator_range_core.hpp> +#include <boost/range/const_iterator.hpp> +#include <boost/range/value_type.hpp> +#include <boost/algorithm/string/detail/find_format_store.hpp> +#include <boost/algorithm/string/detail/replace_storage.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// find_format_all_copy (iterator variant) implementation ---------------------------// + + template< + typename OutputIteratorT, + typename InputT, + typename FinderT, + typename FormatterT, + typename FindResultT, + typename FormatResultT > + inline OutputIteratorT find_format_all_copy_impl2( + OutputIteratorT Output, + const InputT& Input, + FinderT Finder, + FormatterT Formatter, + const FindResultT& FindResult, + const FormatResultT& FormatResult ) + { + typedef BOOST_STRING_TYPENAME + range_const_iterator<InputT>::type input_iterator_type; + + typedef find_format_store< + input_iterator_type, + FormatterT, + FormatResultT > store_type; + + // Create store for the find result + store_type M( FindResult, FormatResult, Formatter ); + + // Initialize last match + input_iterator_type LastMatch=::boost::begin(Input); + + // Iterate through all matches + while( M ) + { + // Copy the beginning of the sequence + Output = std::copy( LastMatch, M.begin(), Output ); + // Copy formatted result + Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output ); + + // Proceed to the next match + LastMatch=M.end(); + M=Finder( LastMatch, ::boost::end(Input) ); + } + + // Copy the rest of the sequence + Output = std::copy( LastMatch, ::boost::end(Input), Output ); + + return Output; + } + + template< + typename OutputIteratorT, + typename InputT, + typename FinderT, + typename FormatterT, + typename FindResultT > + inline OutputIteratorT find_format_all_copy_impl( + OutputIteratorT Output, + const InputT& Input, + FinderT Finder, + FormatterT Formatter, + const FindResultT& FindResult ) + { + if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) { + return ::boost::algorithm::detail::find_format_all_copy_impl2( + Output, + Input, + Finder, + Formatter, + FindResult, + Formatter(FindResult) ); + } else { + return std::copy( ::boost::begin(Input), ::boost::end(Input), Output ); + } + } + + // find_format_all_copy implementation ----------------------------------------------// + + template< + typename InputT, + typename FinderT, + typename FormatterT, + typename FindResultT, + typename FormatResultT > + inline InputT find_format_all_copy_impl2( + const InputT& Input, + FinderT Finder, + FormatterT Formatter, + const FindResultT& FindResult, + const FormatResultT& FormatResult) + { + typedef BOOST_STRING_TYPENAME + range_const_iterator<InputT>::type input_iterator_type; + + typedef find_format_store< + input_iterator_type, + FormatterT, + FormatResultT > store_type; + + // Create store for the find result + store_type M( FindResult, FormatResult, Formatter ); + + // Initialize last match + input_iterator_type LastMatch=::boost::begin(Input); + + // Output temporary + InputT Output; + + // Iterate through all matches + while( M ) + { + // Copy the beginning of the sequence + boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, M.begin() ); + // Copy formatted result + boost::algorithm::detail::insert( Output, ::boost::end(Output), M.format_result() ); + + // Proceed to the next match + LastMatch=M.end(); + M=Finder( LastMatch, ::boost::end(Input) ); + } + + // Copy the rest of the sequence + ::boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, ::boost::end(Input) ); + + return Output; + } + + template< + typename InputT, + typename FinderT, + typename FormatterT, + typename FindResultT > + inline InputT find_format_all_copy_impl( + const InputT& Input, + FinderT Finder, + FormatterT Formatter, + const FindResultT& FindResult) + { + if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) { + return ::boost::algorithm::detail::find_format_all_copy_impl2( + Input, + Finder, + Formatter, + FindResult, + Formatter(FindResult) ); + } else { + return Input; + } + } + + // find_format_all implementation ------------------------------------------------// + + template< + typename InputT, + typename FinderT, + typename FormatterT, + typename FindResultT, + typename FormatResultT > + inline void find_format_all_impl2( + InputT& Input, + FinderT Finder, + FormatterT Formatter, + FindResultT FindResult, + FormatResultT FormatResult) + { + typedef BOOST_STRING_TYPENAME + range_iterator<InputT>::type input_iterator_type; + typedef find_format_store< + input_iterator_type, + FormatterT, + FormatResultT > store_type; + + // Create store for the find result + store_type M( FindResult, FormatResult, Formatter ); + + // Instantiate replacement storage + std::deque< + BOOST_STRING_TYPENAME range_value<InputT>::type> Storage; + + // Initialize replacement iterators + input_iterator_type InsertIt=::boost::begin(Input); + input_iterator_type SearchIt=::boost::begin(Input); + + while( M ) + { + // process the segment + InsertIt=process_segment( + Storage, + Input, + InsertIt, + SearchIt, + M.begin() ); + + // Adjust search iterator + SearchIt=M.end(); + + // Copy formatted replace to the storage + ::boost::algorithm::detail::copy_to_storage( Storage, M.format_result() ); + + // Find range for a next match + M=Finder( SearchIt, ::boost::end(Input) ); + } + + // process the last segment + InsertIt=::boost::algorithm::detail::process_segment( + Storage, + Input, + InsertIt, + SearchIt, + ::boost::end(Input) ); + + if ( Storage.empty() ) + { + // Truncate input + ::boost::algorithm::detail::erase( Input, InsertIt, ::boost::end(Input) ); + } + else + { + // Copy remaining data to the end of input + ::boost::algorithm::detail::insert( Input, ::boost::end(Input), Storage.begin(), Storage.end() ); + } + } + + template< + typename InputT, + typename FinderT, + typename FormatterT, + typename FindResultT > + inline void find_format_all_impl( + InputT& Input, + FinderT Finder, + FormatterT Formatter, + FindResultT FindResult) + { + if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) { + ::boost::algorithm::detail::find_format_all_impl2( + Input, + Finder, + Formatter, + FindResult, + Formatter(FindResult) ); + } + } + + } // namespace detail + } // namespace algorithm +} // namespace boost + +#endif // BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/find_format_store.hpp b/contrib/src/boost/algorithm/string/detail/find_format_store.hpp index 89d2ba4..b9f4a88 100644 --- a/contrib/src/boost/algorithm/string/detail/find_format_store.hpp +++ b/contrib/src/boost/algorithm/string/detail/find_format_store.hpp @@ -1,89 +1,89 @@ -// Boost string_algo library find_format_store.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_FIND_FORMAT_STORE_DETAIL_HPP
-#define BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/range/iterator_range_core.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// temporary format and find result storage --------------------------------//
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
- template<
- typename ForwardIteratorT,
- typename FormatterT,
- typename FormatResultT >
- class find_format_store :
- public iterator_range<ForwardIteratorT>
- {
- public:
- // typedefs
- typedef iterator_range<ForwardIteratorT> base_type;
- typedef FormatterT formatter_type;
- typedef FormatResultT format_result_type;
-
- public:
- // Construction
- find_format_store(
- const base_type& FindResult,
- const format_result_type& FormatResult,
- const formatter_type& Formatter ) :
- base_type(FindResult),
- m_FormatResult(FormatResult),
- m_Formatter(Formatter) {}
-
- // Assignment
- template< typename FindResultT >
- find_format_store& operator=( FindResultT FindResult )
- {
- iterator_range<ForwardIteratorT>::operator=(FindResult);
- if( !this->empty() ) {
- m_FormatResult=m_Formatter(FindResult);
- }
-
- return *this;
- }
-
- // Retrieve format result
- const format_result_type& format_result()
- {
- return m_FormatResult;
- }
-
- private:
- format_result_type m_FormatResult;
- const formatter_type& m_Formatter;
- };
-
- template<typename InputT, typename FindResultT>
- bool check_find_result(InputT&, FindResultT& FindResult)
- {
- typedef BOOST_STRING_TYPENAME
- range_const_iterator<InputT>::type input_iterator_type;
- iterator_range<input_iterator_type> ResultRange(FindResult);
- return !ResultRange.empty();
- }
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-#endif // BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP
+// Boost string_algo library find_format_store.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_FIND_FORMAT_STORE_DETAIL_HPP +#define BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <boost/range/iterator_range_core.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// temporary format and find result storage --------------------------------// + +#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) +#pragma warning(push) +#pragma warning(disable:4512) //assignment operator could not be generated +#endif + template< + typename ForwardIteratorT, + typename FormatterT, + typename FormatResultT > + class find_format_store : + public iterator_range<ForwardIteratorT> + { + public: + // typedefs + typedef iterator_range<ForwardIteratorT> base_type; + typedef FormatterT formatter_type; + typedef FormatResultT format_result_type; + + public: + // Construction + find_format_store( + const base_type& FindResult, + const format_result_type& FormatResult, + const formatter_type& Formatter ) : + base_type(FindResult), + m_FormatResult(FormatResult), + m_Formatter(Formatter) {} + + // Assignment + template< typename FindResultT > + find_format_store& operator=( FindResultT FindResult ) + { + iterator_range<ForwardIteratorT>::operator=(FindResult); + if( !this->empty() ) { + m_FormatResult=m_Formatter(FindResult); + } + + return *this; + } + + // Retrieve format result + const format_result_type& format_result() + { + return m_FormatResult; + } + + private: + format_result_type m_FormatResult; + const formatter_type& m_Formatter; + }; + + template<typename InputT, typename FindResultT> + bool check_find_result(InputT&, FindResultT& FindResult) + { + typedef BOOST_STRING_TYPENAME + range_const_iterator<InputT>::type input_iterator_type; + iterator_range<input_iterator_type> ResultRange(FindResult); + return !ResultRange.empty(); + } + +#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) +#pragma warning(pop) +#endif + } // namespace detail + } // namespace algorithm +} // namespace boost + +#endif // BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/find_iterator.hpp b/contrib/src/boost/algorithm/string/detail/find_iterator.hpp index 505f290..9b78a0f 100644 --- a/contrib/src/boost/algorithm/string/detail/find_iterator.hpp +++ b/contrib/src/boost/algorithm/string/detail/find_iterator.hpp @@ -1,87 +1,87 @@ -// Boost string_algo library find_iterator.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_FIND_ITERATOR_DETAIL_HPP
-#define BOOST_STRING_FIND_ITERATOR_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/iterator/iterator_facade.hpp>
-#include <boost/iterator/iterator_categories.hpp>
-#include <boost/function.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// find_iterator base -----------------------------------------------//
-
- // Find iterator base
- template<typename IteratorT>
- class find_iterator_base
- {
- protected:
- // typedefs
- typedef IteratorT input_iterator_type;
- typedef iterator_range<IteratorT> match_type;
- typedef function2<
- match_type,
- input_iterator_type,
- input_iterator_type> finder_type;
-
- protected:
- // Protected construction/destruction
-
- // Default constructor
- find_iterator_base() {};
- // Copy construction
- find_iterator_base( const find_iterator_base& Other ) :
- m_Finder(Other.m_Finder) {}
-
- // Constructor
- template<typename FinderT>
- find_iterator_base( FinderT Finder, int ) :
- m_Finder(Finder) {}
-
- // Destructor
- ~find_iterator_base() {}
-
- // Find operation
- match_type do_find(
- input_iterator_type Begin,
- input_iterator_type End ) const
- {
- if (!m_Finder.empty())
- {
- return m_Finder(Begin,End);
- }
- else
- {
- return match_type(End,End);
- }
- }
-
- // Check
- bool is_null() const
- {
- return m_Finder.empty();
- }
-
- private:
- // Finder
- finder_type m_Finder;
- };
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_FIND_ITERATOR_DETAIL_HPP
+// Boost string_algo library find_iterator.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_FIND_ITERATOR_DETAIL_HPP +#define BOOST_STRING_FIND_ITERATOR_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <boost/range/iterator_range_core.hpp> +#include <boost/iterator/iterator_facade.hpp> +#include <boost/iterator/iterator_categories.hpp> +#include <boost/function.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// find_iterator base -----------------------------------------------// + + // Find iterator base + template<typename IteratorT> + class find_iterator_base + { + protected: + // typedefs + typedef IteratorT input_iterator_type; + typedef iterator_range<IteratorT> match_type; + typedef function2< + match_type, + input_iterator_type, + input_iterator_type> finder_type; + + protected: + // Protected construction/destruction + + // Default constructor + find_iterator_base() {}; + // Copy construction + find_iterator_base( const find_iterator_base& Other ) : + m_Finder(Other.m_Finder) {} + + // Constructor + template<typename FinderT> + find_iterator_base( FinderT Finder, int ) : + m_Finder(Finder) {} + + // Destructor + ~find_iterator_base() {} + + // Find operation + match_type do_find( + input_iterator_type Begin, + input_iterator_type End ) const + { + if (!m_Finder.empty()) + { + return m_Finder(Begin,End); + } + else + { + return match_type(End,End); + } + } + + // Check + bool is_null() const + { + return m_Finder.empty(); + } + + private: + // Finder + finder_type m_Finder; + }; + + } // namespace detail + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_FIND_ITERATOR_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/finder.hpp b/contrib/src/boost/algorithm/string/detail/finder.hpp index 5bf36a9..a2a9582 100644 --- a/contrib/src/boost/algorithm/string/detail/finder.hpp +++ b/contrib/src/boost/algorithm/string/detail/finder.hpp @@ -1,639 +1,639 @@ -// Boost string_algo library finder.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2006.
-//
-// 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_FINDER_DETAIL_HPP
-#define BOOST_STRING_FINDER_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/algorithm/string/constants.hpp>
-#include <boost/detail/iterator.hpp>
-
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/empty.hpp>
-#include <boost/range/as_literal.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-
-// find first functor -----------------------------------------------//
-
- // find a subsequence in the sequence ( functor )
- /*
- Returns a pair <begin,end> marking the subsequence in the sequence.
- If the find fails, functor returns <End,End>
- */
- template<typename SearchIteratorT,typename PredicateT>
- struct first_finderF
- {
- typedef SearchIteratorT search_iterator_type;
-
- // Construction
- template< typename SearchT >
- first_finderF( const SearchT& Search, PredicateT Comp ) :
- m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
- first_finderF(
- search_iterator_type SearchBegin,
- search_iterator_type SearchEnd,
- PredicateT Comp ) :
- m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {}
-
- // Operation
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- operator()(
- ForwardIteratorT Begin,
- ForwardIteratorT End ) const
- {
- typedef iterator_range<ForwardIteratorT> result_type;
- typedef ForwardIteratorT input_iterator_type;
-
- // Outer loop
- for(input_iterator_type OuterIt=Begin;
- OuterIt!=End;
- ++OuterIt)
- {
- // Sanity check
- if( boost::empty(m_Search) )
- return result_type( End, End );
-
- input_iterator_type InnerIt=OuterIt;
- search_iterator_type SubstrIt=m_Search.begin();
- for(;
- InnerIt!=End && SubstrIt!=m_Search.end();
- ++InnerIt,++SubstrIt)
- {
- if( !( m_Comp(*InnerIt,*SubstrIt) ) )
- break;
- }
-
- // Substring matching succeeded
- if ( SubstrIt==m_Search.end() )
- return result_type( OuterIt, InnerIt );
- }
-
- return result_type( End, End );
- }
-
- private:
- iterator_range<search_iterator_type> m_Search;
- PredicateT m_Comp;
- };
-
-// find last functor -----------------------------------------------//
-
- // find the last match a subsequence in the sequence ( functor )
- /*
- Returns a pair <begin,end> marking the subsequence in the sequence.
- If the find fails, returns <End,End>
- */
- template<typename SearchIteratorT, typename PredicateT>
- struct last_finderF
- {
- typedef SearchIteratorT search_iterator_type;
- typedef first_finderF<
- search_iterator_type,
- PredicateT> first_finder_type;
-
- // Construction
- template< typename SearchT >
- last_finderF( const SearchT& Search, PredicateT Comp ) :
- m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
- last_finderF(
- search_iterator_type SearchBegin,
- search_iterator_type SearchEnd,
- PredicateT Comp ) :
- m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {}
-
- // Operation
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- operator()(
- ForwardIteratorT Begin,
- ForwardIteratorT End ) const
- {
- typedef iterator_range<ForwardIteratorT> result_type;
-
- if( boost::empty(m_Search) )
- return result_type( End, End );
-
- typedef BOOST_STRING_TYPENAME boost::detail::
- iterator_traits<ForwardIteratorT>::iterator_category category;
-
- return findit( Begin, End, category() );
- }
-
- private:
- // forward iterator
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- findit(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- std::forward_iterator_tag ) const
- {
- typedef iterator_range<ForwardIteratorT> result_type;
-
- first_finder_type first_finder(
- m_Search.begin(), m_Search.end(), m_Comp );
-
- result_type M=first_finder( Begin, End );
- result_type Last=M;
-
- while( M )
- {
- Last=M;
- M=first_finder( ::boost::end(M), End );
- }
-
- return Last;
- }
-
- // bidirectional iterator
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- findit(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- std::bidirectional_iterator_tag ) const
- {
- typedef iterator_range<ForwardIteratorT> result_type;
- typedef ForwardIteratorT input_iterator_type;
-
- // Outer loop
- for(input_iterator_type OuterIt=End;
- OuterIt!=Begin; )
- {
- input_iterator_type OuterIt2=--OuterIt;
-
- input_iterator_type InnerIt=OuterIt2;
- search_iterator_type SubstrIt=m_Search.begin();
- for(;
- InnerIt!=End && SubstrIt!=m_Search.end();
- ++InnerIt,++SubstrIt)
- {
- if( !( m_Comp(*InnerIt,*SubstrIt) ) )
- break;
- }
-
- // Substring matching succeeded
- if( SubstrIt==m_Search.end() )
- return result_type( OuterIt2, InnerIt );
- }
-
- return result_type( End, End );
- }
-
- private:
- iterator_range<search_iterator_type> m_Search;
- PredicateT m_Comp;
- };
-
-// find n-th functor -----------------------------------------------//
-
- // find the n-th match of a subsequence in the sequence ( functor )
- /*
- Returns a pair <begin,end> marking the subsequence in the sequence.
- If the find fails, returns <End,End>
- */
- template<typename SearchIteratorT, typename PredicateT>
- struct nth_finderF
- {
- typedef SearchIteratorT search_iterator_type;
- typedef first_finderF<
- search_iterator_type,
- PredicateT> first_finder_type;
- typedef last_finderF<
- search_iterator_type,
- PredicateT> last_finder_type;
-
- // Construction
- template< typename SearchT >
- nth_finderF(
- const SearchT& Search,
- int Nth,
- PredicateT Comp) :
- m_Search(::boost::begin(Search), ::boost::end(Search)),
- m_Nth(Nth),
- m_Comp(Comp) {}
- nth_finderF(
- search_iterator_type SearchBegin,
- search_iterator_type SearchEnd,
- int Nth,
- PredicateT Comp) :
- m_Search(SearchBegin, SearchEnd),
- m_Nth(Nth),
- m_Comp(Comp) {}
-
- // Operation
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- operator()(
- ForwardIteratorT Begin,
- ForwardIteratorT End ) const
- {
- if(m_Nth>=0)
- {
- return find_forward(Begin, End, m_Nth);
- }
- else
- {
- return find_backward(Begin, End, -m_Nth);
- }
-
- }
-
- private:
- // Implementation helpers
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- find_forward(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- unsigned int N) const
- {
- typedef iterator_range<ForwardIteratorT> result_type;
-
- // Sanity check
- if( boost::empty(m_Search) )
- return result_type( End, End );
-
- // Instantiate find functor
- first_finder_type first_finder(
- m_Search.begin(), m_Search.end(), m_Comp );
-
- result_type M( Begin, Begin );
-
- for( unsigned int n=0; n<=N; ++n )
- {
- // find next match
- M=first_finder( ::boost::end(M), End );
-
- if ( !M )
- {
- // Subsequence not found, return
- return M;
- }
- }
-
- return M;
- }
-
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- find_backward(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- unsigned int N) const
- {
- typedef iterator_range<ForwardIteratorT> result_type;
-
- // Sanity check
- if( boost::empty(m_Search) )
- return result_type( End, End );
-
- // Instantiate find functor
- last_finder_type last_finder(
- m_Search.begin(), m_Search.end(), m_Comp );
-
- result_type M( End, End );
-
- for( unsigned int n=1; n<=N; ++n )
- {
- // find next match
- M=last_finder( Begin, ::boost::begin(M) );
-
- if ( !M )
- {
- // Subsequence not found, return
- return M;
- }
- }
-
- return M;
- }
-
-
- private:
- iterator_range<search_iterator_type> m_Search;
- int m_Nth;
- PredicateT m_Comp;
- };
-
-// find head/tail implementation helpers ---------------------------//
-
- template<typename ForwardIteratorT>
- iterator_range<ForwardIteratorT>
- find_head_impl(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- unsigned int N,
- std::forward_iterator_tag )
- {
- typedef ForwardIteratorT input_iterator_type;
- typedef iterator_range<ForwardIteratorT> result_type;
-
- input_iterator_type It=Begin;
- for(
- unsigned int Index=0;
- Index<N && It!=End; ++Index,++It ) {};
-
- return result_type( Begin, It );
- }
-
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- find_head_impl(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- unsigned int N,
- std::random_access_iterator_tag )
- {
- typedef iterator_range<ForwardIteratorT> result_type;
-
- if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) )
- return result_type( Begin, End );
-
- return result_type(Begin,Begin+N);
- }
-
- // Find head implementation
- template<typename ForwardIteratorT>
- iterator_range<ForwardIteratorT>
- find_head_impl(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- unsigned int N )
- {
- typedef BOOST_STRING_TYPENAME boost::detail::
- iterator_traits<ForwardIteratorT>::iterator_category category;
-
- return ::boost::algorithm::detail::find_head_impl( Begin, End, N, category() );
- }
-
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- find_tail_impl(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- unsigned int N,
- std::forward_iterator_tag )
- {
- typedef ForwardIteratorT input_iterator_type;
- typedef iterator_range<ForwardIteratorT> result_type;
-
- unsigned int Index=0;
- input_iterator_type It=Begin;
- input_iterator_type It2=Begin;
-
- // Advance It2 by N increments
- for( Index=0; Index<N && It2!=End; ++Index,++It2 ) {};
-
- // Advance It, It2 to the end
- for(; It2!=End; ++It,++It2 ) {};
-
- return result_type( It, It2 );
- }
-
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- find_tail_impl(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- unsigned int N,
- std::bidirectional_iterator_tag )
- {
- typedef ForwardIteratorT input_iterator_type;
- typedef iterator_range<ForwardIteratorT> result_type;
-
- input_iterator_type It=End;
- for(
- unsigned int Index=0;
- Index<N && It!=Begin; ++Index,--It ) {};
-
- return result_type( It, End );
- }
-
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- find_tail_impl(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- unsigned int N,
- std::random_access_iterator_tag )
- {
- typedef iterator_range<ForwardIteratorT> result_type;
-
- if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) )
- return result_type( Begin, End );
-
- return result_type( End-N, End );
- }
-
- // Operation
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- find_tail_impl(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- unsigned int N )
- {
- typedef BOOST_STRING_TYPENAME boost::detail::
- iterator_traits<ForwardIteratorT>::iterator_category category;
-
- return ::boost::algorithm::detail::find_tail_impl( Begin, End, N, category() );
- }
-
-
-
-// find head functor -----------------------------------------------//
-
-
- // find a head in the sequence ( functor )
- /*
- This functor find a head of the specified range. For
- a specified N, the head is a subsequence of N starting
- elements of the range.
- */
- struct head_finderF
- {
- // Construction
- head_finderF( int N ) : m_N(N) {}
-
- // Operation
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- operator()(
- ForwardIteratorT Begin,
- ForwardIteratorT End ) const
- {
- if(m_N>=0)
- {
- return ::boost::algorithm::detail::find_head_impl( Begin, End, m_N );
- }
- else
- {
- iterator_range<ForwardIteratorT> Res=
- ::boost::algorithm::detail::find_tail_impl( Begin, End, -m_N );
-
- return ::boost::make_iterator_range(Begin, Res.begin());
- }
- }
-
- private:
- int m_N;
- };
-
-// find tail functor -----------------------------------------------//
-
-
- // find a tail in the sequence ( functor )
- /*
- This functor find a tail of the specified range. For
- a specified N, the head is a subsequence of N starting
- elements of the range.
- */
- struct tail_finderF
- {
- // Construction
- tail_finderF( int N ) : m_N(N) {}
-
- // Operation
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- operator()(
- ForwardIteratorT Begin,
- ForwardIteratorT End ) const
- {
- if(m_N>=0)
- {
- return ::boost::algorithm::detail::find_tail_impl( Begin, End, m_N );
- }
- else
- {
- iterator_range<ForwardIteratorT> Res=
- ::boost::algorithm::detail::find_head_impl( Begin, End, -m_N );
-
- return ::boost::make_iterator_range(Res.end(), End);
- }
- }
-
- private:
- int m_N;
- };
-
-// find token functor -----------------------------------------------//
-
- // find a token in a sequence ( functor )
- /*
- This find functor finds a token specified be a predicate
- in a sequence. It is equivalent of std::find algorithm,
- with an exception that it return range instead of a single
- iterator.
-
- If bCompress is set to true, adjacent matching tokens are
- concatenated into one match.
- */
- template< typename PredicateT >
- struct token_finderF
- {
- // Construction
- token_finderF(
- PredicateT Pred,
- token_compress_mode_type eCompress=token_compress_off ) :
- m_Pred(Pred), m_eCompress(eCompress) {}
-
- // Operation
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- operator()(
- ForwardIteratorT Begin,
- ForwardIteratorT End ) const
- {
- typedef iterator_range<ForwardIteratorT> result_type;
-
- ForwardIteratorT It=std::find_if( Begin, End, m_Pred );
-
- if( It==End )
- {
- return result_type( End, End );
- }
- else
- {
- ForwardIteratorT It2=It;
-
- if( m_eCompress==token_compress_on )
- {
- // Find first non-matching character
- while( It2!=End && m_Pred(*It2) ) ++It2;
- }
- else
- {
- // Advance by one position
- ++It2;
- }
-
- return result_type( It, It2 );
- }
- }
-
- private:
- PredicateT m_Pred;
- token_compress_mode_type m_eCompress;
- };
-
-// find range functor -----------------------------------------------//
-
- // find a range in the sequence ( functor )
- /*
- This functor actually does not perform any find operation.
- It always returns given iterator range as a result.
- */
- template<typename ForwardIterator1T>
- struct range_finderF
- {
- typedef ForwardIterator1T input_iterator_type;
- typedef iterator_range<input_iterator_type> result_type;
-
- // Construction
- range_finderF(
- input_iterator_type Begin,
- input_iterator_type End ) : m_Range(Begin, End) {}
-
- range_finderF(const iterator_range<input_iterator_type>& Range) :
- m_Range(Range) {}
-
- // Operation
- template< typename ForwardIterator2T >
- iterator_range<ForwardIterator2T>
- operator()(
- ForwardIterator2T,
- ForwardIterator2T ) const
- {
-#if BOOST_WORKAROUND( __MWERKS__, <= 0x3003 )
- return iterator_range<const ForwardIterator2T>(this->m_Range);
-#else
- return m_Range;
-#endif
- }
-
- private:
- iterator_range<input_iterator_type> m_Range;
- };
-
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-#endif // BOOST_STRING_FINDER_DETAIL_HPP
+// Boost string_algo library finder.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2006. +// +// 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_FINDER_DETAIL_HPP +#define BOOST_STRING_FINDER_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <boost/algorithm/string/constants.hpp> +#include <boost/detail/iterator.hpp> + +#include <boost/range/iterator_range_core.hpp> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> +#include <boost/range/empty.hpp> +#include <boost/range/as_literal.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + + +// find first functor -----------------------------------------------// + + // find a subsequence in the sequence ( functor ) + /* + Returns a pair <begin,end> marking the subsequence in the sequence. + If the find fails, functor returns <End,End> + */ + template<typename SearchIteratorT,typename PredicateT> + struct first_finderF + { + typedef SearchIteratorT search_iterator_type; + + // Construction + template< typename SearchT > + first_finderF( const SearchT& Search, PredicateT Comp ) : + m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {} + first_finderF( + search_iterator_type SearchBegin, + search_iterator_type SearchEnd, + PredicateT Comp ) : + m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {} + + // Operation + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + operator()( + ForwardIteratorT Begin, + ForwardIteratorT End ) const + { + typedef iterator_range<ForwardIteratorT> result_type; + typedef ForwardIteratorT input_iterator_type; + + // Outer loop + for(input_iterator_type OuterIt=Begin; + OuterIt!=End; + ++OuterIt) + { + // Sanity check + if( boost::empty(m_Search) ) + return result_type( End, End ); + + input_iterator_type InnerIt=OuterIt; + search_iterator_type SubstrIt=m_Search.begin(); + for(; + InnerIt!=End && SubstrIt!=m_Search.end(); + ++InnerIt,++SubstrIt) + { + if( !( m_Comp(*InnerIt,*SubstrIt) ) ) + break; + } + + // Substring matching succeeded + if ( SubstrIt==m_Search.end() ) + return result_type( OuterIt, InnerIt ); + } + + return result_type( End, End ); + } + + private: + iterator_range<search_iterator_type> m_Search; + PredicateT m_Comp; + }; + +// find last functor -----------------------------------------------// + + // find the last match a subsequence in the sequence ( functor ) + /* + Returns a pair <begin,end> marking the subsequence in the sequence. + If the find fails, returns <End,End> + */ + template<typename SearchIteratorT, typename PredicateT> + struct last_finderF + { + typedef SearchIteratorT search_iterator_type; + typedef first_finderF< + search_iterator_type, + PredicateT> first_finder_type; + + // Construction + template< typename SearchT > + last_finderF( const SearchT& Search, PredicateT Comp ) : + m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {} + last_finderF( + search_iterator_type SearchBegin, + search_iterator_type SearchEnd, + PredicateT Comp ) : + m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {} + + // Operation + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + operator()( + ForwardIteratorT Begin, + ForwardIteratorT End ) const + { + typedef iterator_range<ForwardIteratorT> result_type; + + if( boost::empty(m_Search) ) + return result_type( End, End ); + + typedef BOOST_STRING_TYPENAME boost::detail:: + iterator_traits<ForwardIteratorT>::iterator_category category; + + return findit( Begin, End, category() ); + } + + private: + // forward iterator + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + findit( + ForwardIteratorT Begin, + ForwardIteratorT End, + std::forward_iterator_tag ) const + { + typedef iterator_range<ForwardIteratorT> result_type; + + first_finder_type first_finder( + m_Search.begin(), m_Search.end(), m_Comp ); + + result_type M=first_finder( Begin, End ); + result_type Last=M; + + while( M ) + { + Last=M; + M=first_finder( ::boost::end(M), End ); + } + + return Last; + } + + // bidirectional iterator + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + findit( + ForwardIteratorT Begin, + ForwardIteratorT End, + std::bidirectional_iterator_tag ) const + { + typedef iterator_range<ForwardIteratorT> result_type; + typedef ForwardIteratorT input_iterator_type; + + // Outer loop + for(input_iterator_type OuterIt=End; + OuterIt!=Begin; ) + { + input_iterator_type OuterIt2=--OuterIt; + + input_iterator_type InnerIt=OuterIt2; + search_iterator_type SubstrIt=m_Search.begin(); + for(; + InnerIt!=End && SubstrIt!=m_Search.end(); + ++InnerIt,++SubstrIt) + { + if( !( m_Comp(*InnerIt,*SubstrIt) ) ) + break; + } + + // Substring matching succeeded + if( SubstrIt==m_Search.end() ) + return result_type( OuterIt2, InnerIt ); + } + + return result_type( End, End ); + } + + private: + iterator_range<search_iterator_type> m_Search; + PredicateT m_Comp; + }; + +// find n-th functor -----------------------------------------------// + + // find the n-th match of a subsequence in the sequence ( functor ) + /* + Returns a pair <begin,end> marking the subsequence in the sequence. + If the find fails, returns <End,End> + */ + template<typename SearchIteratorT, typename PredicateT> + struct nth_finderF + { + typedef SearchIteratorT search_iterator_type; + typedef first_finderF< + search_iterator_type, + PredicateT> first_finder_type; + typedef last_finderF< + search_iterator_type, + PredicateT> last_finder_type; + + // Construction + template< typename SearchT > + nth_finderF( + const SearchT& Search, + int Nth, + PredicateT Comp) : + m_Search(::boost::begin(Search), ::boost::end(Search)), + m_Nth(Nth), + m_Comp(Comp) {} + nth_finderF( + search_iterator_type SearchBegin, + search_iterator_type SearchEnd, + int Nth, + PredicateT Comp) : + m_Search(SearchBegin, SearchEnd), + m_Nth(Nth), + m_Comp(Comp) {} + + // Operation + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + operator()( + ForwardIteratorT Begin, + ForwardIteratorT End ) const + { + if(m_Nth>=0) + { + return find_forward(Begin, End, m_Nth); + } + else + { + return find_backward(Begin, End, -m_Nth); + } + + } + + private: + // Implementation helpers + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + find_forward( + ForwardIteratorT Begin, + ForwardIteratorT End, + unsigned int N) const + { + typedef iterator_range<ForwardIteratorT> result_type; + + // Sanity check + if( boost::empty(m_Search) ) + return result_type( End, End ); + + // Instantiate find functor + first_finder_type first_finder( + m_Search.begin(), m_Search.end(), m_Comp ); + + result_type M( Begin, Begin ); + + for( unsigned int n=0; n<=N; ++n ) + { + // find next match + M=first_finder( ::boost::end(M), End ); + + if ( !M ) + { + // Subsequence not found, return + return M; + } + } + + return M; + } + + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + find_backward( + ForwardIteratorT Begin, + ForwardIteratorT End, + unsigned int N) const + { + typedef iterator_range<ForwardIteratorT> result_type; + + // Sanity check + if( boost::empty(m_Search) ) + return result_type( End, End ); + + // Instantiate find functor + last_finder_type last_finder( + m_Search.begin(), m_Search.end(), m_Comp ); + + result_type M( End, End ); + + for( unsigned int n=1; n<=N; ++n ) + { + // find next match + M=last_finder( Begin, ::boost::begin(M) ); + + if ( !M ) + { + // Subsequence not found, return + return M; + } + } + + return M; + } + + + private: + iterator_range<search_iterator_type> m_Search; + int m_Nth; + PredicateT m_Comp; + }; + +// find head/tail implementation helpers ---------------------------// + + template<typename ForwardIteratorT> + iterator_range<ForwardIteratorT> + find_head_impl( + ForwardIteratorT Begin, + ForwardIteratorT End, + unsigned int N, + std::forward_iterator_tag ) + { + typedef ForwardIteratorT input_iterator_type; + typedef iterator_range<ForwardIteratorT> result_type; + + input_iterator_type It=Begin; + for( + unsigned int Index=0; + Index<N && It!=End; ++Index,++It ) {}; + + return result_type( Begin, It ); + } + + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + find_head_impl( + ForwardIteratorT Begin, + ForwardIteratorT End, + unsigned int N, + std::random_access_iterator_tag ) + { + typedef iterator_range<ForwardIteratorT> result_type; + + if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) ) + return result_type( Begin, End ); + + return result_type(Begin,Begin+N); + } + + // Find head implementation + template<typename ForwardIteratorT> + iterator_range<ForwardIteratorT> + find_head_impl( + ForwardIteratorT Begin, + ForwardIteratorT End, + unsigned int N ) + { + typedef BOOST_STRING_TYPENAME boost::detail:: + iterator_traits<ForwardIteratorT>::iterator_category category; + + return ::boost::algorithm::detail::find_head_impl( Begin, End, N, category() ); + } + + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + find_tail_impl( + ForwardIteratorT Begin, + ForwardIteratorT End, + unsigned int N, + std::forward_iterator_tag ) + { + typedef ForwardIteratorT input_iterator_type; + typedef iterator_range<ForwardIteratorT> result_type; + + unsigned int Index=0; + input_iterator_type It=Begin; + input_iterator_type It2=Begin; + + // Advance It2 by N increments + for( Index=0; Index<N && It2!=End; ++Index,++It2 ) {}; + + // Advance It, It2 to the end + for(; It2!=End; ++It,++It2 ) {}; + + return result_type( It, It2 ); + } + + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + find_tail_impl( + ForwardIteratorT Begin, + ForwardIteratorT End, + unsigned int N, + std::bidirectional_iterator_tag ) + { + typedef ForwardIteratorT input_iterator_type; + typedef iterator_range<ForwardIteratorT> result_type; + + input_iterator_type It=End; + for( + unsigned int Index=0; + Index<N && It!=Begin; ++Index,--It ) {}; + + return result_type( It, End ); + } + + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + find_tail_impl( + ForwardIteratorT Begin, + ForwardIteratorT End, + unsigned int N, + std::random_access_iterator_tag ) + { + typedef iterator_range<ForwardIteratorT> result_type; + + if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) ) + return result_type( Begin, End ); + + return result_type( End-N, End ); + } + + // Operation + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + find_tail_impl( + ForwardIteratorT Begin, + ForwardIteratorT End, + unsigned int N ) + { + typedef BOOST_STRING_TYPENAME boost::detail:: + iterator_traits<ForwardIteratorT>::iterator_category category; + + return ::boost::algorithm::detail::find_tail_impl( Begin, End, N, category() ); + } + + + +// find head functor -----------------------------------------------// + + + // find a head in the sequence ( functor ) + /* + This functor find a head of the specified range. For + a specified N, the head is a subsequence of N starting + elements of the range. + */ + struct head_finderF + { + // Construction + head_finderF( int N ) : m_N(N) {} + + // Operation + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + operator()( + ForwardIteratorT Begin, + ForwardIteratorT End ) const + { + if(m_N>=0) + { + return ::boost::algorithm::detail::find_head_impl( Begin, End, m_N ); + } + else + { + iterator_range<ForwardIteratorT> Res= + ::boost::algorithm::detail::find_tail_impl( Begin, End, -m_N ); + + return ::boost::make_iterator_range(Begin, Res.begin()); + } + } + + private: + int m_N; + }; + +// find tail functor -----------------------------------------------// + + + // find a tail in the sequence ( functor ) + /* + This functor find a tail of the specified range. For + a specified N, the head is a subsequence of N starting + elements of the range. + */ + struct tail_finderF + { + // Construction + tail_finderF( int N ) : m_N(N) {} + + // Operation + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + operator()( + ForwardIteratorT Begin, + ForwardIteratorT End ) const + { + if(m_N>=0) + { + return ::boost::algorithm::detail::find_tail_impl( Begin, End, m_N ); + } + else + { + iterator_range<ForwardIteratorT> Res= + ::boost::algorithm::detail::find_head_impl( Begin, End, -m_N ); + + return ::boost::make_iterator_range(Res.end(), End); + } + } + + private: + int m_N; + }; + +// find token functor -----------------------------------------------// + + // find a token in a sequence ( functor ) + /* + This find functor finds a token specified be a predicate + in a sequence. It is equivalent of std::find algorithm, + with an exception that it return range instead of a single + iterator. + + If bCompress is set to true, adjacent matching tokens are + concatenated into one match. + */ + template< typename PredicateT > + struct token_finderF + { + // Construction + token_finderF( + PredicateT Pred, + token_compress_mode_type eCompress=token_compress_off ) : + m_Pred(Pred), m_eCompress(eCompress) {} + + // Operation + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + operator()( + ForwardIteratorT Begin, + ForwardIteratorT End ) const + { + typedef iterator_range<ForwardIteratorT> result_type; + + ForwardIteratorT It=std::find_if( Begin, End, m_Pred ); + + if( It==End ) + { + return result_type( End, End ); + } + else + { + ForwardIteratorT It2=It; + + if( m_eCompress==token_compress_on ) + { + // Find first non-matching character + while( It2!=End && m_Pred(*It2) ) ++It2; + } + else + { + // Advance by one position + ++It2; + } + + return result_type( It, It2 ); + } + } + + private: + PredicateT m_Pred; + token_compress_mode_type m_eCompress; + }; + +// find range functor -----------------------------------------------// + + // find a range in the sequence ( functor ) + /* + This functor actually does not perform any find operation. + It always returns given iterator range as a result. + */ + template<typename ForwardIterator1T> + struct range_finderF + { + typedef ForwardIterator1T input_iterator_type; + typedef iterator_range<input_iterator_type> result_type; + + // Construction + range_finderF( + input_iterator_type Begin, + input_iterator_type End ) : m_Range(Begin, End) {} + + range_finderF(const iterator_range<input_iterator_type>& Range) : + m_Range(Range) {} + + // Operation + template< typename ForwardIterator2T > + iterator_range<ForwardIterator2T> + operator()( + ForwardIterator2T, + ForwardIterator2T ) const + { +#if BOOST_WORKAROUND( __MWERKS__, <= 0x3003 ) + return iterator_range<const ForwardIterator2T>(this->m_Range); +#else + return m_Range; +#endif + } + + private: + iterator_range<input_iterator_type> m_Range; + }; + + + } // namespace detail + } // namespace algorithm +} // namespace boost + +#endif // BOOST_STRING_FINDER_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/formatter.hpp b/contrib/src/boost/algorithm/string/detail/formatter.hpp index 9fd16e2..c071822 100644 --- a/contrib/src/boost/algorithm/string/detail/formatter.hpp +++ b/contrib/src/boost/algorithm/string/detail/formatter.hpp @@ -1,119 +1,119 @@ -// Boost string_algo library formatter.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_FORMATTER_DETAIL_HPP
-#define BOOST_STRING_FORMATTER_DETAIL_HPP
-
-
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/const_iterator.hpp>
-
-#include <boost/algorithm/string/detail/util.hpp>
-
-// generic replace functors -----------------------------------------------//
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// const format functor ----------------------------------------------------//
-
- // constant format functor
- template<typename RangeT>
- struct const_formatF
- {
- private:
- typedef BOOST_STRING_TYPENAME
- range_const_iterator<RangeT>::type format_iterator;
- typedef iterator_range<format_iterator> result_type;
-
- public:
- // Construction
- const_formatF(const RangeT& Format) :
- m_Format(::boost::begin(Format), ::boost::end(Format)) {}
-
- // Operation
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
- template<typename Range2T>
- result_type& operator()(const Range2T&)
- {
- return m_Format;
- }
-#endif
-
- template<typename Range2T>
- const result_type& operator()(const Range2T&) const
- {
- return m_Format;
- }
-
- private:
- result_type m_Format;
- };
-
-// identity format functor ----------------------------------------------------//
-
- // identity format functor
- template<typename RangeT>
- struct identity_formatF
- {
- // Operation
- template< typename Range2T >
- const RangeT& operator()(const Range2T& Replace) const
- {
- return RangeT(::boost::begin(Replace), ::boost::end(Replace));
- }
- };
-
-// empty format functor ( used by erase ) ------------------------------------//
-
- // empty format functor
- template< typename CharT >
- struct empty_formatF
- {
- template< typename ReplaceT >
- empty_container<CharT> operator()(const ReplaceT&) const
- {
- return empty_container<CharT>();
- }
- };
-
-// dissect format functor ----------------------------------------------------//
-
- // dissect format functor
- template<typename FinderT>
- struct dissect_formatF
- {
- public:
- // Construction
- dissect_formatF(FinderT Finder) :
- m_Finder(Finder) {}
-
- // Operation
- template<typename RangeT>
- inline iterator_range<
- BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
- operator()(const RangeT& Replace) const
- {
- return m_Finder(::boost::begin(Replace), ::boost::end(Replace));
- }
-
- private:
- FinderT m_Finder;
- };
-
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-#endif // BOOST_STRING_FORMATTER_DETAIL_HPP
+// Boost string_algo library formatter.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_FORMATTER_DETAIL_HPP +#define BOOST_STRING_FORMATTER_DETAIL_HPP + + +#include <boost/range/iterator_range_core.hpp> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> +#include <boost/range/const_iterator.hpp> + +#include <boost/algorithm/string/detail/util.hpp> + +// generic replace functors -----------------------------------------------// + +namespace boost { + namespace algorithm { + namespace detail { + +// const format functor ----------------------------------------------------// + + // constant format functor + template<typename RangeT> + struct const_formatF + { + private: + typedef BOOST_STRING_TYPENAME + range_const_iterator<RangeT>::type format_iterator; + typedef iterator_range<format_iterator> result_type; + + public: + // Construction + const_formatF(const RangeT& Format) : + m_Format(::boost::begin(Format), ::boost::end(Format)) {} + + // Operation +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + template<typename Range2T> + result_type& operator()(const Range2T&) + { + return m_Format; + } +#endif + + template<typename Range2T> + const result_type& operator()(const Range2T&) const + { + return m_Format; + } + + private: + result_type m_Format; + }; + +// identity format functor ----------------------------------------------------// + + // identity format functor + template<typename RangeT> + struct identity_formatF + { + // Operation + template< typename Range2T > + const RangeT& operator()(const Range2T& Replace) const + { + return RangeT(::boost::begin(Replace), ::boost::end(Replace)); + } + }; + +// empty format functor ( used by erase ) ------------------------------------// + + // empty format functor + template< typename CharT > + struct empty_formatF + { + template< typename ReplaceT > + empty_container<CharT> operator()(const ReplaceT&) const + { + return empty_container<CharT>(); + } + }; + +// dissect format functor ----------------------------------------------------// + + // dissect format functor + template<typename FinderT> + struct dissect_formatF + { + public: + // Construction + dissect_formatF(FinderT Finder) : + m_Finder(Finder) {} + + // Operation + template<typename RangeT> + inline iterator_range< + BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> + operator()(const RangeT& Replace) const + { + return m_Finder(::boost::begin(Replace), ::boost::end(Replace)); + } + + private: + FinderT m_Finder; + }; + + + } // namespace detail + } // namespace algorithm +} // namespace boost + +#endif // BOOST_STRING_FORMATTER_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/predicate.hpp b/contrib/src/boost/algorithm/string/detail/predicate.hpp index bd95d40..5acf3cc 100644 --- a/contrib/src/boost/algorithm/string/detail/predicate.hpp +++ b/contrib/src/boost/algorithm/string/detail/predicate.hpp @@ -1,77 +1,77 @@ -// Boost string_algo library predicate.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_PREDICATE_DETAIL_HPP
-#define BOOST_STRING_PREDICATE_DETAIL_HPP
-
-#include <iterator>
-#include <boost/algorithm/string/find.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// ends_with predicate implementation ----------------------------------//
-
- template<
- typename ForwardIterator1T,
- typename ForwardIterator2T,
- typename PredicateT>
- inline bool ends_with_iter_select(
- ForwardIterator1T Begin,
- ForwardIterator1T End,
- ForwardIterator2T SubBegin,
- ForwardIterator2T SubEnd,
- PredicateT Comp,
- std::bidirectional_iterator_tag)
- {
- ForwardIterator1T it=End;
- ForwardIterator2T pit=SubEnd;
- for(;it!=Begin && pit!=SubBegin;)
- {
- if( !(Comp(*(--it),*(--pit))) )
- return false;
- }
-
- return pit==SubBegin;
- }
-
- template<
- typename ForwardIterator1T,
- typename ForwardIterator2T,
- typename PredicateT>
- inline bool ends_with_iter_select(
- ForwardIterator1T Begin,
- ForwardIterator1T End,
- ForwardIterator2T SubBegin,
- ForwardIterator2T SubEnd,
- PredicateT Comp,
- std::forward_iterator_tag)
- {
- if ( SubBegin==SubEnd )
- {
- // empty subsequence check
- return true;
- }
-
- iterator_range<ForwardIterator1T> Result
- =last_finder(
- ::boost::make_iterator_range(SubBegin, SubEnd),
- Comp)(Begin, End);
-
- return !Result.empty() && Result.end()==End;
- }
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_PREDICATE_DETAIL_HPP
+// Boost string_algo library predicate.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_PREDICATE_DETAIL_HPP +#define BOOST_STRING_PREDICATE_DETAIL_HPP + +#include <iterator> +#include <boost/algorithm/string/find.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// ends_with predicate implementation ----------------------------------// + + template< + typename ForwardIterator1T, + typename ForwardIterator2T, + typename PredicateT> + inline bool ends_with_iter_select( + ForwardIterator1T Begin, + ForwardIterator1T End, + ForwardIterator2T SubBegin, + ForwardIterator2T SubEnd, + PredicateT Comp, + std::bidirectional_iterator_tag) + { + ForwardIterator1T it=End; + ForwardIterator2T pit=SubEnd; + for(;it!=Begin && pit!=SubBegin;) + { + if( !(Comp(*(--it),*(--pit))) ) + return false; + } + + return pit==SubBegin; + } + + template< + typename ForwardIterator1T, + typename ForwardIterator2T, + typename PredicateT> + inline bool ends_with_iter_select( + ForwardIterator1T Begin, + ForwardIterator1T End, + ForwardIterator2T SubBegin, + ForwardIterator2T SubEnd, + PredicateT Comp, + std::forward_iterator_tag) + { + if ( SubBegin==SubEnd ) + { + // empty subsequence check + return true; + } + + iterator_range<ForwardIterator1T> Result + =last_finder( + ::boost::make_iterator_range(SubBegin, SubEnd), + Comp)(Begin, End); + + return !Result.empty() && Result.end()==End; + } + + } // namespace detail + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_PREDICATE_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/replace_storage.hpp b/contrib/src/boost/algorithm/string/detail/replace_storage.hpp index 13f4e08..db35e4c 100644 --- a/contrib/src/boost/algorithm/string/detail/replace_storage.hpp +++ b/contrib/src/boost/algorithm/string/detail/replace_storage.hpp @@ -1,159 +1,159 @@ -// Boost string_algo library replace_storage.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_REPLACE_STORAGE_DETAIL_HPP
-#define BOOST_STRING_REPLACE_STORAGE_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <algorithm>
-#include <boost/mpl/bool.hpp>
-#include <boost/algorithm/string/sequence_traits.hpp>
-#include <boost/algorithm/string/detail/sequence.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// storage handling routines -----------------------------------------------//
-
- template< typename StorageT, typename OutputIteratorT >
- inline OutputIteratorT move_from_storage(
- StorageT& Storage,
- OutputIteratorT DestBegin,
- OutputIteratorT DestEnd )
- {
- OutputIteratorT OutputIt=DestBegin;
-
- while( !Storage.empty() && OutputIt!=DestEnd )
- {
- *OutputIt=Storage.front();
- Storage.pop_front();
- ++OutputIt;
- }
-
- return OutputIt;
- }
-
- template< typename StorageT, typename WhatT >
- inline void copy_to_storage(
- StorageT& Storage,
- const WhatT& What )
- {
- Storage.insert( Storage.end(), ::boost::begin(What), ::boost::end(What) );
- }
-
-
-// process segment routine -----------------------------------------------//
-
- template< bool HasStableIterators >
- struct process_segment_helper
- {
- // Optimized version of process_segment for generic sequence
- template<
- typename StorageT,
- typename InputT,
- typename ForwardIteratorT >
- ForwardIteratorT operator()(
- StorageT& Storage,
- InputT& /*Input*/,
- ForwardIteratorT InsertIt,
- ForwardIteratorT SegmentBegin,
- ForwardIteratorT SegmentEnd )
- {
- // Copy data from the storage until the beginning of the segment
- ForwardIteratorT It=::boost::algorithm::detail::move_from_storage( Storage, InsertIt, SegmentBegin );
-
- // 3 cases are possible :
- // a) Storage is empty, It==SegmentBegin
- // b) Storage is empty, It!=SegmentBegin
- // c) Storage is not empty
-
- if( Storage.empty() )
- {
- if( It==SegmentBegin )
- {
- // Case a) everything is grand, just return end of segment
- return SegmentEnd;
- }
- else
- {
- // Case b) move the segment backwards
- return std::copy( SegmentBegin, SegmentEnd, It );
- }
- }
- else
- {
- // Case c) -> shift the segment to the left and keep the overlap in the storage
- while( It!=SegmentEnd )
- {
- // Store value into storage
- Storage.push_back( *It );
- // Get the top from the storage and put it here
- *It=Storage.front();
- Storage.pop_front();
-
- // Advance
- ++It;
- }
-
- return It;
- }
- }
- };
-
- template<>
- struct process_segment_helper< true >
- {
- // Optimized version of process_segment for list-like sequence
- template<
- typename StorageT,
- typename InputT,
- typename ForwardIteratorT >
- ForwardIteratorT operator()(
- StorageT& Storage,
- InputT& Input,
- ForwardIteratorT InsertIt,
- ForwardIteratorT SegmentBegin,
- ForwardIteratorT SegmentEnd )
-
- {
- // Call replace to do the job
- ::boost::algorithm::detail::replace( Input, InsertIt, SegmentBegin, Storage );
- // Empty the storage
- Storage.clear();
- // Iterators were not changed, simply return the end of segment
- return SegmentEnd;
- }
- };
-
- // Process one segment in the replace_all algorithm
- template<
- typename StorageT,
- typename InputT,
- typename ForwardIteratorT >
- inline ForwardIteratorT process_segment(
- StorageT& Storage,
- InputT& Input,
- ForwardIteratorT InsertIt,
- ForwardIteratorT SegmentBegin,
- ForwardIteratorT SegmentEnd )
- {
- return
- process_segment_helper<
- has_stable_iterators<InputT>::value>()(
- Storage, Input, InsertIt, SegmentBegin, SegmentEnd );
- }
-
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-#endif // BOOST_STRING_REPLACE_STORAGE_DETAIL_HPP
+// Boost string_algo library replace_storage.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_REPLACE_STORAGE_DETAIL_HPP +#define BOOST_STRING_REPLACE_STORAGE_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <algorithm> +#include <boost/mpl/bool.hpp> +#include <boost/algorithm/string/sequence_traits.hpp> +#include <boost/algorithm/string/detail/sequence.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// storage handling routines -----------------------------------------------// + + template< typename StorageT, typename OutputIteratorT > + inline OutputIteratorT move_from_storage( + StorageT& Storage, + OutputIteratorT DestBegin, + OutputIteratorT DestEnd ) + { + OutputIteratorT OutputIt=DestBegin; + + while( !Storage.empty() && OutputIt!=DestEnd ) + { + *OutputIt=Storage.front(); + Storage.pop_front(); + ++OutputIt; + } + + return OutputIt; + } + + template< typename StorageT, typename WhatT > + inline void copy_to_storage( + StorageT& Storage, + const WhatT& What ) + { + Storage.insert( Storage.end(), ::boost::begin(What), ::boost::end(What) ); + } + + +// process segment routine -----------------------------------------------// + + template< bool HasStableIterators > + struct process_segment_helper + { + // Optimized version of process_segment for generic sequence + template< + typename StorageT, + typename InputT, + typename ForwardIteratorT > + ForwardIteratorT operator()( + StorageT& Storage, + InputT& /*Input*/, + ForwardIteratorT InsertIt, + ForwardIteratorT SegmentBegin, + ForwardIteratorT SegmentEnd ) + { + // Copy data from the storage until the beginning of the segment + ForwardIteratorT It=::boost::algorithm::detail::move_from_storage( Storage, InsertIt, SegmentBegin ); + + // 3 cases are possible : + // a) Storage is empty, It==SegmentBegin + // b) Storage is empty, It!=SegmentBegin + // c) Storage is not empty + + if( Storage.empty() ) + { + if( It==SegmentBegin ) + { + // Case a) everything is grand, just return end of segment + return SegmentEnd; + } + else + { + // Case b) move the segment backwards + return std::copy( SegmentBegin, SegmentEnd, It ); + } + } + else + { + // Case c) -> shift the segment to the left and keep the overlap in the storage + while( It!=SegmentEnd ) + { + // Store value into storage + Storage.push_back( *It ); + // Get the top from the storage and put it here + *It=Storage.front(); + Storage.pop_front(); + + // Advance + ++It; + } + + return It; + } + } + }; + + template<> + struct process_segment_helper< true > + { + // Optimized version of process_segment for list-like sequence + template< + typename StorageT, + typename InputT, + typename ForwardIteratorT > + ForwardIteratorT operator()( + StorageT& Storage, + InputT& Input, + ForwardIteratorT InsertIt, + ForwardIteratorT SegmentBegin, + ForwardIteratorT SegmentEnd ) + + { + // Call replace to do the job + ::boost::algorithm::detail::replace( Input, InsertIt, SegmentBegin, Storage ); + // Empty the storage + Storage.clear(); + // Iterators were not changed, simply return the end of segment + return SegmentEnd; + } + }; + + // Process one segment in the replace_all algorithm + template< + typename StorageT, + typename InputT, + typename ForwardIteratorT > + inline ForwardIteratorT process_segment( + StorageT& Storage, + InputT& Input, + ForwardIteratorT InsertIt, + ForwardIteratorT SegmentBegin, + ForwardIteratorT SegmentEnd ) + { + return + process_segment_helper< + has_stable_iterators<InputT>::value>()( + Storage, Input, InsertIt, SegmentBegin, SegmentEnd ); + } + + + } // namespace detail + } // namespace algorithm +} // namespace boost + +#endif // BOOST_STRING_REPLACE_STORAGE_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/sequence.hpp b/contrib/src/boost/algorithm/string/detail/sequence.hpp index 8c8bd97..dc47409 100644 --- a/contrib/src/boost/algorithm/string/detail/sequence.hpp +++ b/contrib/src/boost/algorithm/string/detail/sequence.hpp @@ -1,200 +1,200 @@ -// Boost string_algo library sequence.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_DETAIL_SEQUENCE_HPP
-#define BOOST_STRING_DETAIL_SEQUENCE_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/logical.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-#include <boost/algorithm/string/sequence_traits.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// insert helpers -------------------------------------------------//
-
- template< typename InputT, typename ForwardIteratorT >
- inline void insert(
- InputT& Input,
- BOOST_STRING_TYPENAME InputT::iterator At,
- ForwardIteratorT Begin,
- ForwardIteratorT End )
- {
- Input.insert( At, Begin, End );
- }
-
- template< typename InputT, typename InsertT >
- inline void insert(
- InputT& Input,
- BOOST_STRING_TYPENAME InputT::iterator At,
- const InsertT& Insert )
- {
- ::boost::algorithm::detail::insert( Input, At, ::boost::begin(Insert), ::boost::end(Insert) );
- }
-
-// erase helper ---------------------------------------------------//
-
- // Erase a range in the sequence
- /*
- Returns the iterator pointing just after the erase subrange
- */
- template< typename InputT >
- inline typename InputT::iterator erase(
- InputT& Input,
- BOOST_STRING_TYPENAME InputT::iterator From,
- BOOST_STRING_TYPENAME InputT::iterator To )
- {
- return Input.erase( From, To );
- }
-
-// replace helper implementation ----------------------------------//
-
- // Optimized version of replace for generic sequence containers
- // Assumption: insert and erase are expensive
- template< bool HasConstTimeOperations >
- struct replace_const_time_helper
- {
- template< typename InputT, typename ForwardIteratorT >
- void operator()(
- InputT& Input,
- BOOST_STRING_TYPENAME InputT::iterator From,
- BOOST_STRING_TYPENAME InputT::iterator To,
- ForwardIteratorT Begin,
- ForwardIteratorT End )
- {
- // Copy data to the container ( as much as possible )
- ForwardIteratorT InsertIt=Begin;
- BOOST_STRING_TYPENAME InputT::iterator InputIt=From;
- for(; InsertIt!=End && InputIt!=To; InsertIt++, InputIt++ )
- {
- *InputIt=*InsertIt;
- }
-
- if ( InsertIt!=End )
- {
- // Replace sequence is longer, insert it
- Input.insert( InputIt, InsertIt, End );
- }
- else
- {
- if ( InputIt!=To )
- {
- // Replace sequence is shorter, erase the rest
- Input.erase( InputIt, To );
- }
- }
- }
- };
-
- template<>
- struct replace_const_time_helper< true >
- {
- // Const-time erase and insert methods -> use them
- template< typename InputT, typename ForwardIteratorT >
- void operator()(
- InputT& Input,
- BOOST_STRING_TYPENAME InputT::iterator From,
- BOOST_STRING_TYPENAME InputT::iterator To,
- ForwardIteratorT Begin,
- ForwardIteratorT End )
- {
- BOOST_STRING_TYPENAME InputT::iterator At=Input.erase( From, To );
- if ( Begin!=End )
- {
- if(!Input.empty())
- {
- Input.insert( At, Begin, End );
- }
- else
- {
- Input.insert( Input.begin(), Begin, End );
- }
- }
- }
- };
-
- // No native replace method
- template< bool HasNative >
- struct replace_native_helper
- {
- template< typename InputT, typename ForwardIteratorT >
- void operator()(
- InputT& Input,
- BOOST_STRING_TYPENAME InputT::iterator From,
- BOOST_STRING_TYPENAME InputT::iterator To,
- ForwardIteratorT Begin,
- ForwardIteratorT End )
- {
- replace_const_time_helper<
- boost::mpl::and_<
- has_const_time_insert<InputT>,
- has_const_time_erase<InputT> >::value >()(
- Input, From, To, Begin, End );
- }
- };
-
- // Container has native replace method
- template<>
- struct replace_native_helper< true >
- {
- template< typename InputT, typename ForwardIteratorT >
- void operator()(
- InputT& Input,
- BOOST_STRING_TYPENAME InputT::iterator From,
- BOOST_STRING_TYPENAME InputT::iterator To,
- ForwardIteratorT Begin,
- ForwardIteratorT End )
- {
- Input.replace( From, To, Begin, End );
- }
- };
-
-// replace helper -------------------------------------------------//
-
- template< typename InputT, typename ForwardIteratorT >
- inline void replace(
- InputT& Input,
- BOOST_STRING_TYPENAME InputT::iterator From,
- BOOST_STRING_TYPENAME InputT::iterator To,
- ForwardIteratorT Begin,
- ForwardIteratorT End )
- {
- replace_native_helper< has_native_replace<InputT>::value >()(
- Input, From, To, Begin, End );
- }
-
- template< typename InputT, typename InsertT >
- inline void replace(
- InputT& Input,
- BOOST_STRING_TYPENAME InputT::iterator From,
- BOOST_STRING_TYPENAME InputT::iterator To,
- const InsertT& Insert )
- {
- if(From!=To)
- {
- ::boost::algorithm::detail::replace( Input, From, To, ::boost::begin(Insert), ::boost::end(Insert) );
- }
- else
- {
- ::boost::algorithm::detail::insert( Input, From, ::boost::begin(Insert), ::boost::end(Insert) );
- }
- }
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_DETAIL_SEQUENCE_HPP
+// Boost string_algo library sequence.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_DETAIL_SEQUENCE_HPP +#define BOOST_STRING_DETAIL_SEQUENCE_HPP + +#include <boost/algorithm/string/config.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/mpl/logical.hpp> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> + +#include <boost/algorithm/string/sequence_traits.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// insert helpers -------------------------------------------------// + + template< typename InputT, typename ForwardIteratorT > + inline void insert( + InputT& Input, + BOOST_STRING_TYPENAME InputT::iterator At, + ForwardIteratorT Begin, + ForwardIteratorT End ) + { + Input.insert( At, Begin, End ); + } + + template< typename InputT, typename InsertT > + inline void insert( + InputT& Input, + BOOST_STRING_TYPENAME InputT::iterator At, + const InsertT& Insert ) + { + ::boost::algorithm::detail::insert( Input, At, ::boost::begin(Insert), ::boost::end(Insert) ); + } + +// erase helper ---------------------------------------------------// + + // Erase a range in the sequence + /* + Returns the iterator pointing just after the erase subrange + */ + template< typename InputT > + inline typename InputT::iterator erase( + InputT& Input, + BOOST_STRING_TYPENAME InputT::iterator From, + BOOST_STRING_TYPENAME InputT::iterator To ) + { + return Input.erase( From, To ); + } + +// replace helper implementation ----------------------------------// + + // Optimized version of replace for generic sequence containers + // Assumption: insert and erase are expensive + template< bool HasConstTimeOperations > + struct replace_const_time_helper + { + template< typename InputT, typename ForwardIteratorT > + void operator()( + InputT& Input, + BOOST_STRING_TYPENAME InputT::iterator From, + BOOST_STRING_TYPENAME InputT::iterator To, + ForwardIteratorT Begin, + ForwardIteratorT End ) + { + // Copy data to the container ( as much as possible ) + ForwardIteratorT InsertIt=Begin; + BOOST_STRING_TYPENAME InputT::iterator InputIt=From; + for(; InsertIt!=End && InputIt!=To; InsertIt++, InputIt++ ) + { + *InputIt=*InsertIt; + } + + if ( InsertIt!=End ) + { + // Replace sequence is longer, insert it + Input.insert( InputIt, InsertIt, End ); + } + else + { + if ( InputIt!=To ) + { + // Replace sequence is shorter, erase the rest + Input.erase( InputIt, To ); + } + } + } + }; + + template<> + struct replace_const_time_helper< true > + { + // Const-time erase and insert methods -> use them + template< typename InputT, typename ForwardIteratorT > + void operator()( + InputT& Input, + BOOST_STRING_TYPENAME InputT::iterator From, + BOOST_STRING_TYPENAME InputT::iterator To, + ForwardIteratorT Begin, + ForwardIteratorT End ) + { + BOOST_STRING_TYPENAME InputT::iterator At=Input.erase( From, To ); + if ( Begin!=End ) + { + if(!Input.empty()) + { + Input.insert( At, Begin, End ); + } + else + { + Input.insert( Input.begin(), Begin, End ); + } + } + } + }; + + // No native replace method + template< bool HasNative > + struct replace_native_helper + { + template< typename InputT, typename ForwardIteratorT > + void operator()( + InputT& Input, + BOOST_STRING_TYPENAME InputT::iterator From, + BOOST_STRING_TYPENAME InputT::iterator To, + ForwardIteratorT Begin, + ForwardIteratorT End ) + { + replace_const_time_helper< + boost::mpl::and_< + has_const_time_insert<InputT>, + has_const_time_erase<InputT> >::value >()( + Input, From, To, Begin, End ); + } + }; + + // Container has native replace method + template<> + struct replace_native_helper< true > + { + template< typename InputT, typename ForwardIteratorT > + void operator()( + InputT& Input, + BOOST_STRING_TYPENAME InputT::iterator From, + BOOST_STRING_TYPENAME InputT::iterator To, + ForwardIteratorT Begin, + ForwardIteratorT End ) + { + Input.replace( From, To, Begin, End ); + } + }; + +// replace helper -------------------------------------------------// + + template< typename InputT, typename ForwardIteratorT > + inline void replace( + InputT& Input, + BOOST_STRING_TYPENAME InputT::iterator From, + BOOST_STRING_TYPENAME InputT::iterator To, + ForwardIteratorT Begin, + ForwardIteratorT End ) + { + replace_native_helper< has_native_replace<InputT>::value >()( + Input, From, To, Begin, End ); + } + + template< typename InputT, typename InsertT > + inline void replace( + InputT& Input, + BOOST_STRING_TYPENAME InputT::iterator From, + BOOST_STRING_TYPENAME InputT::iterator To, + const InsertT& Insert ) + { + if(From!=To) + { + ::boost::algorithm::detail::replace( Input, From, To, ::boost::begin(Insert), ::boost::end(Insert) ); + } + else + { + ::boost::algorithm::detail::insert( Input, From, ::boost::begin(Insert), ::boost::end(Insert) ); + } + } + + } // namespace detail + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_DETAIL_SEQUENCE_HPP diff --git a/contrib/src/boost/algorithm/string/detail/trim.hpp b/contrib/src/boost/algorithm/string/detail/trim.hpp index b53072c..1233e49 100644 --- a/contrib/src/boost/algorithm/string/detail/trim.hpp +++ b/contrib/src/boost/algorithm/string/detail/trim.hpp @@ -1,95 +1,95 @@ -// Boost string_algo library trim.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_TRIM_DETAIL_HPP
-#define BOOST_STRING_TRIM_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/detail/iterator.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// trim iterator helper -----------------------------------------------//
-
- template< typename ForwardIteratorT, typename PredicateT >
- inline ForwardIteratorT trim_end_iter_select(
- ForwardIteratorT InBegin,
- ForwardIteratorT InEnd,
- PredicateT IsSpace,
- std::forward_iterator_tag )
- {
- ForwardIteratorT TrimIt=InBegin;
-
- for( ForwardIteratorT It=InBegin; It!=InEnd; ++It )
- {
- if ( !IsSpace(*It) )
- {
- TrimIt=It;
- ++TrimIt;
- }
- }
-
- return TrimIt;
- }
-
- template< typename ForwardIteratorT, typename PredicateT >
- inline ForwardIteratorT trim_end_iter_select(
- ForwardIteratorT InBegin,
- ForwardIteratorT InEnd,
- PredicateT IsSpace,
- std::bidirectional_iterator_tag )
- {
- for( ForwardIteratorT It=InEnd; It!=InBegin; )
- {
- if ( !IsSpace(*(--It)) )
- return ++It;
- }
-
- return InBegin;
- }
- // Search for first non matching character from the beginning of the sequence
- template< typename ForwardIteratorT, typename PredicateT >
- inline ForwardIteratorT trim_begin(
- ForwardIteratorT InBegin,
- ForwardIteratorT InEnd,
- PredicateT IsSpace )
- {
- ForwardIteratorT It=InBegin;
- for(; It!=InEnd; ++It )
- {
- if (!IsSpace(*It))
- return It;
- }
-
- return It;
- }
-
- // Search for first non matching character from the end of the sequence
- template< typename ForwardIteratorT, typename PredicateT >
- inline ForwardIteratorT trim_end(
- ForwardIteratorT InBegin,
- ForwardIteratorT InEnd,
- PredicateT IsSpace )
- {
- typedef BOOST_STRING_TYPENAME boost::detail::
- iterator_traits<ForwardIteratorT>::iterator_category category;
-
- return ::boost::algorithm::detail::trim_end_iter_select( InBegin, InEnd, IsSpace, category() );
- }
-
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_TRIM_DETAIL_HPP
+// Boost string_algo library trim.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_TRIM_DETAIL_HPP +#define BOOST_STRING_TRIM_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <boost/detail/iterator.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// trim iterator helper -----------------------------------------------// + + template< typename ForwardIteratorT, typename PredicateT > + inline ForwardIteratorT trim_end_iter_select( + ForwardIteratorT InBegin, + ForwardIteratorT InEnd, + PredicateT IsSpace, + std::forward_iterator_tag ) + { + ForwardIteratorT TrimIt=InBegin; + + for( ForwardIteratorT It=InBegin; It!=InEnd; ++It ) + { + if ( !IsSpace(*It) ) + { + TrimIt=It; + ++TrimIt; + } + } + + return TrimIt; + } + + template< typename ForwardIteratorT, typename PredicateT > + inline ForwardIteratorT trim_end_iter_select( + ForwardIteratorT InBegin, + ForwardIteratorT InEnd, + PredicateT IsSpace, + std::bidirectional_iterator_tag ) + { + for( ForwardIteratorT It=InEnd; It!=InBegin; ) + { + if ( !IsSpace(*(--It)) ) + return ++It; + } + + return InBegin; + } + // Search for first non matching character from the beginning of the sequence + template< typename ForwardIteratorT, typename PredicateT > + inline ForwardIteratorT trim_begin( + ForwardIteratorT InBegin, + ForwardIteratorT InEnd, + PredicateT IsSpace ) + { + ForwardIteratorT It=InBegin; + for(; It!=InEnd; ++It ) + { + if (!IsSpace(*It)) + return It; + } + + return It; + } + + // Search for first non matching character from the end of the sequence + template< typename ForwardIteratorT, typename PredicateT > + inline ForwardIteratorT trim_end( + ForwardIteratorT InBegin, + ForwardIteratorT InEnd, + PredicateT IsSpace ) + { + typedef BOOST_STRING_TYPENAME boost::detail:: + iterator_traits<ForwardIteratorT>::iterator_category category; + + return ::boost::algorithm::detail::trim_end_iter_select( InBegin, InEnd, IsSpace, category() ); + } + + + } // namespace detail + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_TRIM_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/util.hpp b/contrib/src/boost/algorithm/string/detail/util.hpp index 4954fc2..cf4a8b1 100644 --- a/contrib/src/boost/algorithm/string/detail/util.hpp +++ b/contrib/src/boost/algorithm/string/detail/util.hpp @@ -1,106 +1,106 @@ -// Boost string_algo library util.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_UTIL_DETAIL_HPP
-#define BOOST_STRING_UTIL_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <functional>
-#include <boost/range/iterator_range_core.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// empty container -----------------------------------------------//
-
- // empty_container
- /*
- This class represents always empty container,
- containing elements of type CharT.
-
- It is supposed to be used in a const version only
- */
- template< typename CharT >
- struct empty_container
- {
- typedef empty_container<CharT> type;
- typedef CharT value_type;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
- typedef const value_type& reference;
- typedef const value_type& const_reference;
- typedef const value_type* iterator;
- typedef const value_type* const_iterator;
-
-
- // Operations
- const_iterator begin() const
- {
- return reinterpret_cast<const_iterator>(0);
- }
-
- const_iterator end() const
- {
- return reinterpret_cast<const_iterator>(0);
- }
-
- bool empty() const
- {
- return false;
- }
-
- size_type size() const
- {
- return 0;
- }
- };
-
-// bounded copy algorithm -----------------------------------------------//
-
- // Bounded version of the std::copy algorithm
- template<typename InputIteratorT, typename OutputIteratorT>
- inline OutputIteratorT bounded_copy(
- InputIteratorT First,
- InputIteratorT Last,
- OutputIteratorT DestFirst,
- OutputIteratorT DestLast )
- {
- InputIteratorT InputIt=First;
- OutputIteratorT OutputIt=DestFirst;
- for(; InputIt!=Last && OutputIt!=DestLast; InputIt++, OutputIt++ )
- {
- *OutputIt=*InputIt;
- }
-
- return OutputIt;
- }
-
-// iterator range utilities -----------------------------------------//
-
- // copy range functor
- template<
- typename SeqT,
- typename IteratorT=BOOST_STRING_TYPENAME SeqT::const_iterator >
- struct copy_iterator_rangeF :
- public std::unary_function< iterator_range<IteratorT>, SeqT >
- {
- SeqT operator()( const iterator_range<IteratorT>& Range ) const
- {
- return copy_range<SeqT>(Range);
- }
- };
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_UTIL_DETAIL_HPP
+// Boost string_algo library util.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_UTIL_DETAIL_HPP +#define BOOST_STRING_UTIL_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <functional> +#include <boost/range/iterator_range_core.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// empty container -----------------------------------------------// + + // empty_container + /* + This class represents always empty container, + containing elements of type CharT. + + It is supposed to be used in a const version only + */ + template< typename CharT > + struct empty_container + { + typedef empty_container<CharT> type; + typedef CharT value_type; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + typedef const value_type& reference; + typedef const value_type& const_reference; + typedef const value_type* iterator; + typedef const value_type* const_iterator; + + + // Operations + const_iterator begin() const + { + return reinterpret_cast<const_iterator>(0); + } + + const_iterator end() const + { + return reinterpret_cast<const_iterator>(0); + } + + bool empty() const + { + return false; + } + + size_type size() const + { + return 0; + } + }; + +// bounded copy algorithm -----------------------------------------------// + + // Bounded version of the std::copy algorithm + template<typename InputIteratorT, typename OutputIteratorT> + inline OutputIteratorT bounded_copy( + InputIteratorT First, + InputIteratorT Last, + OutputIteratorT DestFirst, + OutputIteratorT DestLast ) + { + InputIteratorT InputIt=First; + OutputIteratorT OutputIt=DestFirst; + for(; InputIt!=Last && OutputIt!=DestLast; InputIt++, OutputIt++ ) + { + *OutputIt=*InputIt; + } + + return OutputIt; + } + +// iterator range utilities -----------------------------------------// + + // copy range functor + template< + typename SeqT, + typename IteratorT=BOOST_STRING_TYPENAME SeqT::const_iterator > + struct copy_iterator_rangeF : + public std::unary_function< iterator_range<IteratorT>, SeqT > + { + SeqT operator()( const iterator_range<IteratorT>& Range ) const + { + return copy_range<SeqT>(Range); + } + }; + + } // namespace detail + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_UTIL_DETAIL_HPP |