EIC code displayed by LXR master/​include/​boost/​algorithm/​string/​detail/​classification.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:28:23

 //  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 <cstring>
 #include <functional>
 #include <locale>
 
 #include <boost/range/begin.hpp>
 #include <boost/range/distance.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(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_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

This page was automatically generated by the 2.3.7 LXR engine. The LXR team