/Src/Dependencies/Boost/boost/algorithm/string/compare.hpp

  1//  Boost string_algo library compare.hpp header file  -------------------------//
  2
  3//  Copyright Pavol Droba 2002-2006.
  4//
  5// Distributed under the Boost Software License, Version 1.0.
  6//    (See accompanying file LICENSE_1_0.txt or copy at
  7//          http://www.boost.org/LICENSE_1_0.txt)
  8
  9//  See http://www.boost.org/ for updates, documentation, and revision history.
 10
 11#ifndef BOOST_STRING_COMPARE_HPP
 12#define BOOST_STRING_COMPARE_HPP
 13
 14#include <boost/algorithm/string/config.hpp>
 15#include <locale>
 16
 17/*! \file
 18    Defines element comparison predicates. Many algorithms in this library can
 19    take an additional argument with a predicate used to compare elements.
 20    This makes it possible, for instance, to have case insensitive versions
 21    of the algorithms.
 22*/
 23
 24namespace boost {
 25    namespace algorithm {
 26
 27        //  is_equal functor  -----------------------------------------------//
 28
 29        //! is_equal functor
 30        /*!
 31            Standard STL equal_to only handle comparison between arguments
 32            of the same type. This is a less restrictive version which wraps operator ==.
 33        */
 34        struct is_equal
 35        {
 36            //! Function operator
 37            /*!
 38                Compare two operands for equality
 39            */
 40            template< typename T1, typename T2 >
 41                bool operator()( const T1& Arg1, const T2& Arg2 ) const
 42            {
 43                return Arg1==Arg2;
 44            }
 45        };
 46
 47        //! case insensitive version of is_equal
 48        /*!
 49            Case insensitive comparison predicate. Comparison is done using
 50            specified locales.
 51        */
 52        struct is_iequal
 53        {
 54            //! Constructor
 55            /*!
 56                \param Loc locales used for comparison
 57            */
 58            is_iequal( const std::locale& Loc=std::locale() ) :
 59                m_Loc( Loc ) {}
 60
 61            //! Function operator
 62            /*!
 63                Compare two operands. Case is ignored.
 64            */
 65            template< typename T1, typename T2 >
 66                bool operator()( const T1& Arg1, const T2& Arg2 ) const
 67            {
 68                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
 69                    return std::toupper(Arg1)==std::toupper(Arg2);
 70                #else
 71                    return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc);
 72                #endif
 73            }
 74
 75        private:
 76            std::locale m_Loc;
 77        };
 78
 79        //  is_less functor  -----------------------------------------------//
 80
 81        //! is_less functor
 82        /*!
 83            Convenient version of standard std::less. Operation is templated, therefore it is 
 84            not required to specify the exact types upon the construction
 85         */
 86        struct is_less
 87        {
 88            //! Functor operation
 89            /*!
 90                Compare two operands using > operator
 91             */
 92            template< typename T1, typename T2 >
 93                bool operator()( const T1& Arg1, const T2& Arg2 ) const
 94            {
 95                return Arg1<Arg2;
 96            }
 97        };
 98
 99
100        //! case insensitive version of is_less
101        /*!
102            Case insensitive comparison predicate. Comparison is done using
103            specified locales.
104        */
105        struct is_iless
106        {
107            //! Constructor
108            /*!
109                \param Loc locales used for comparison
110            */
111            is_iless( const std::locale& Loc=std::locale() ) :
112                m_Loc( Loc ) {}
113
114            //! Function operator
115            /*!
116                Compare two operands. Case is ignored.
117            */
118            template< typename T1, typename T2 >
119                bool operator()( const T1& Arg1, const T2& Arg2 ) const
120            {
121                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
122                    return std::toupper(Arg1)<std::toupper(Arg2);
123                #else
124                    return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc);
125                #endif
126            }
127
128        private:
129            std::locale m_Loc;
130        };
131
132        //  is_not_greater functor  -----------------------------------------------//
133
134        //! is_not_greater functor
135        /*!
136            Convenient version of standard std::not_greater_to. Operation is templated, therefore it is 
137            not required to specify the exact types upon the construction
138         */
139        struct is_not_greater
140        {
141            //! Functor operation
142            /*!
143                Compare two operands using > operator
144             */
145            template< typename T1, typename T2 >
146                bool operator()( const T1& Arg1, const T2& Arg2 ) const
147            {
148                return Arg1<=Arg2;
149            }
150        };
151
152
153        //! case insensitive version of is_not_greater
154        /*!
155            Case insensitive comparison predicate. Comparison is done using
156            specified locales.
157        */
158        struct is_not_igreater
159        {
160            //! Constructor
161            /*!
162                \param Loc locales used for comparison
163            */
164            is_not_igreater( const std::locale& Loc=std::locale() ) :
165                m_Loc( Loc ) {}
166
167            //! Function operator
168            /*!
169                Compare two operands. Case is ignored.
170            */
171            template< typename T1, typename T2 >
172                bool operator()( const T1& Arg1, const T2& Arg2 ) const
173            {
174                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
175                    return std::toupper(Arg1)<=std::toupper(Arg2);
176                #else
177                    return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc);
178                #endif
179            }
180
181        private:
182            std::locale m_Loc;
183        };
184
185
186    } // namespace algorithm
187
188    // pull names to the boost namespace
189    using algorithm::is_equal;
190    using algorithm::is_iequal;
191    using algorithm::is_less;
192    using algorithm::is_iless;
193    using algorithm::is_not_greater;
194    using algorithm::is_not_igreater;
195
196} // namespace boost
197
198
199#endif  // BOOST_STRING_COMPARE_HPP