summaryrefslogtreecommitdiffstats
path: root/contrib/src/boost/algorithm/string/detail/classification.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/src/boost/algorithm/string/detail/classification.hpp')
-rw-r--r--contrib/src/boost/algorithm/string/detail/classification.hpp706
1 files changed, 353 insertions, 353 deletions
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
generated by cgit v0.12 at 2024-06-26 02:01:12 (GMT)