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
200

source code of boost/boost/algorithm/string/compare.hpp