PageRenderTime 39ms CodeModel.GetById 13ms app.highlight 22ms RepoModel.GetById 1ms app.codeStats 0ms

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

http://hadesmem.googlecode.com/
C++ Header | 312 lines | 126 code | 30 blank | 156 comment | 0 complexity | bd80597c419cda231a783961bad73c08 MD5 | raw file
  1//  Boost string_algo library classification.hpp header file  ---------------------------//
  2
  3//  Copyright Pavol Droba 2002-2003.
  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_CLASSIFICATION_HPP
 12#define BOOST_STRING_CLASSIFICATION_HPP
 13
 14#include <algorithm>
 15#include <locale>
 16#include <boost/range/value_type.hpp>
 17#include <boost/range/as_literal.hpp>
 18#include <boost/algorithm/string/detail/classification.hpp>
 19#include <boost/algorithm/string/predicate_facade.hpp>
 20
 21
 22/*! \file
 23    Classification predicates are included in the library to give 
 24    some more convenience when using algorithms like \c trim() and \c all(). 
 25    They wrap functionality of STL classification functions ( e.g. \c std::isspace() )
 26    into generic functors. 
 27*/
 28
 29namespace boost {
 30    namespace algorithm {
 31
 32//  classification functor generator -------------------------------------//
 33
 34        //! is_classified predicate
 35        /*!
 36            Construct the \c is_classified predicate. This predicate holds if the input is
 37            of specified \c std::ctype category.
 38
 39            \param Type A \c std::ctype category
 40            \param Loc A locale used for classification
 41            \return An instance of the \c is_classified predicate 
 42        */
 43        inline detail::is_classifiedF
 44        is_classified(std::ctype_base::mask Type, const std::locale& Loc=std::locale())
 45        {
 46            return detail::is_classifiedF(Type, Loc);
 47        }
 48
 49        //! is_space predicate
 50        /*!
 51            Construct the \c is_classified predicate for the \c ctype_base::space category.   
 52
 53            \param Loc A locale used for classification
 54            \return An instance of the \c is_classified predicate
 55        */
 56        inline detail::is_classifiedF 
 57        is_space(const std::locale& Loc=std::locale())
 58        {
 59            return detail::is_classifiedF(std::ctype_base::space, Loc);
 60        }
 61
 62        //! is_alnum predicate
 63        /*!
 64            Construct the \c is_classified predicate for the \c ctype_base::alnum category.   
 65
 66            \param Loc A locale used for classification
 67            \return An instance of the \c is_classified predicate 
 68        */
 69        inline detail::is_classifiedF 
 70        is_alnum(const std::locale& Loc=std::locale())
 71        {
 72            return detail::is_classifiedF(std::ctype_base::alnum, Loc);
 73        }
 74
 75        //! is_alpha predicate
 76        /*!
 77            Construct the \c is_classified predicate for the \c ctype_base::alpha category.   
 78
 79            \param Loc A locale used for classification
 80            \return An instance of the \c is_classified predicate 
 81        */
 82        inline detail::is_classifiedF 
 83        is_alpha(const std::locale& Loc=std::locale())
 84        {
 85            return detail::is_classifiedF(std::ctype_base::alpha, Loc);
 86        }
 87
 88        //! is_cntrl predicate
 89        /*!
 90            Construct the \c is_classified predicate for the \c ctype_base::cntrl category.   
 91
 92            \param Loc A locale used for classification
 93            \return An instance of the \c is_classified predicate 
 94        */
 95        inline detail::is_classifiedF 
 96        is_cntrl(const std::locale& Loc=std::locale())
 97        {
 98            return detail::is_classifiedF(std::ctype_base::cntrl, Loc);
 99        }
100
101        //! is_digit predicate
102        /*!
103            Construct the \c is_classified predicate for the \c ctype_base::digit category.   
104
105            \param Loc A locale used for classification
106            \return An instance of the \c is_classified predicate 
107        */
108        inline detail::is_classifiedF 
109        is_digit(const std::locale& Loc=std::locale())
110        {
111            return detail::is_classifiedF(std::ctype_base::digit, Loc);
112        }
113
114        //! is_graph predicate
115        /*!
116            Construct the \c is_classified predicate for the \c ctype_base::graph category.   
117
118            \param Loc A locale used for classification
119            \return An instance of the \c is_classified predicate 
120        */
121        inline detail::is_classifiedF
122        is_graph(const std::locale& Loc=std::locale())
123        {
124            return detail::is_classifiedF(std::ctype_base::graph, Loc);
125        }
126
127        //! is_lower predicate
128        /*!
129            Construct the \c is_classified predicate for the \c ctype_base::lower category.   
130
131            \param Loc A locale used for classification
132            \return An instance of \c is_classified predicate 
133        */
134        inline detail::is_classifiedF 
135        is_lower(const std::locale& Loc=std::locale())
136        {
137            return detail::is_classifiedF(std::ctype_base::lower, Loc);
138        }
139
140        //! is_print predicate
141        /*!
142            Construct the \c is_classified predicate for the \c ctype_base::print category.   
143
144            \param Loc A locale used for classification
145            \return An instance of the \c is_classified predicate 
146        */
147        inline detail::is_classifiedF 
148        is_print(const std::locale& Loc=std::locale())
149        {
150            return detail::is_classifiedF(std::ctype_base::print, Loc);
151        }
152
153        //! is_punct predicate
154        /*!
155            Construct the \c is_classified predicate for the \c ctype_base::punct category.   
156
157            \param Loc A locale used for classification
158            \return An instance of the \c is_classified predicate 
159        */
160        inline detail::is_classifiedF 
161        is_punct(const std::locale& Loc=std::locale())
162        {
163            return detail::is_classifiedF(std::ctype_base::punct, Loc);
164        }
165
166        //! is_upper predicate
167        /*!
168            Construct the \c is_classified predicate for the \c ctype_base::upper category.   
169
170            \param Loc A locale used for classification
171            \return An instance of the \c is_classified predicate 
172        */
173        inline detail::is_classifiedF 
174        is_upper(const std::locale& Loc=std::locale())
175        {
176            return detail::is_classifiedF(std::ctype_base::upper, Loc);
177        }
178
179        //! is_xdigit predicate
180        /*!
181            Construct the \c is_classified predicate for the \c ctype_base::xdigit category.  
182
183            \param Loc A locale used for classification
184            \return An instance of the \c is_classified predicate 
185        */
186        inline detail::is_classifiedF 
187        is_xdigit(const std::locale& Loc=std::locale())
188        {
189            return detail::is_classifiedF(std::ctype_base::xdigit, Loc);
190        }
191
192        //! is_any_of predicate
193        /*!
194            Construct the \c is_any_of predicate. The predicate holds if the input
195            is included in the specified set of characters.
196
197            \param Set A set of characters to be recognized
198            \return An instance of the \c is_any_of predicate 
199        */
200        template<typename RangeT>
201        inline detail::is_any_ofF<
202            BOOST_STRING_TYPENAME range_value<RangeT>::type> 
203        is_any_of( const RangeT& Set )
204        {
205            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_set(boost::as_literal(Set));
206            return detail::is_any_ofF<BOOST_STRING_TYPENAME range_value<RangeT>::type>(lit_set); 
207        }
208
209        //! is_from_range predicate
210        /*!
211            Construct the \c is_from_range predicate. The predicate holds if the input
212            is included in the specified range. (i.e. From <= Ch <= To )
213
214            \param From The start of the range
215            \param To The end of the range
216            \return An instance of the \c is_from_range predicate 
217        */
218        template<typename CharT>
219        inline detail::is_from_rangeF<CharT> is_from_range(CharT From, CharT To)
220        {
221            return detail::is_from_rangeF<CharT>(From,To); 
222        }
223        
224        // predicate combinators ---------------------------------------------------//
225
226        //! predicate 'and' composition predicate
227        /*!
228            Construct the \c class_and predicate. This predicate can be used
229            to logically combine two classification predicates. \c class_and holds,
230            if both predicates return true.
231
232            \param Pred1 The first predicate
233            \param Pred2 The second predicate
234            \return An instance of the \c class_and predicate     
235        */
236        template<typename Pred1T, typename Pred2T>
237        inline detail::pred_andF<Pred1T, Pred2T>
238        operator&&( 
239            const predicate_facade<Pred1T>& Pred1, 
240            const predicate_facade<Pred2T>& Pred2 )
241        {    
242            // Doing the static_cast with the pointer instead of the reference
243            // is a workaround for some compilers which have problems with
244            // static_cast's of template references, i.e. CW8. /grafik/
245            return detail::pred_andF<Pred1T,Pred2T>(
246                *static_cast<const Pred1T*>(&Pred1), 
247                *static_cast<const Pred2T*>(&Pred2) );
248        }
249
250        //! predicate 'or' composition predicate
251        /*!
252            Construct the \c class_or predicate. This predicate can be used
253            to logically combine two classification predicates. \c class_or holds,
254            if one of the predicates return true.
255
256            \param Pred1 The first predicate
257            \param Pred2 The second predicate
258            \return An instance of the \c class_or predicate     
259        */
260        template<typename Pred1T, typename Pred2T>
261        inline detail::pred_orF<Pred1T, Pred2T>
262        operator||( 
263            const predicate_facade<Pred1T>& Pred1, 
264            const predicate_facade<Pred2T>& Pred2 )
265        {    
266            // Doing the static_cast with the pointer instead of the reference
267            // is a workaround for some compilers which have problems with
268            // static_cast's of template references, i.e. CW8. /grafik/
269            return detail::pred_orF<Pred1T,Pred2T>(
270                *static_cast<const Pred1T*>(&Pred1), 
271                *static_cast<const Pred2T*>(&Pred2));
272        }
273
274        //! predicate negation operator
275        /*!
276            Construct the \c class_not predicate. This predicate represents a negation. 
277            \c class_or holds if of the predicates return false.
278
279            \param Pred The predicate to be negated
280            \return An instance of the \c class_not predicate     
281        */
282        template<typename PredT>
283        inline detail::pred_notF<PredT>
284        operator!( const predicate_facade<PredT>& Pred )
285        {
286            // Doing the static_cast with the pointer instead of the reference
287            // is a workaround for some compilers which have problems with
288            // static_cast's of template references, i.e. CW8. /grafik/
289            return detail::pred_notF<PredT>(*static_cast<const PredT*>(&Pred)); 
290        }
291
292    } // namespace algorithm
293
294    // pull names to the boost namespace
295    using algorithm::is_classified;
296    using algorithm::is_space;
297    using algorithm::is_alnum;
298    using algorithm::is_alpha;
299    using algorithm::is_cntrl;
300    using algorithm::is_digit;
301    using algorithm::is_graph;
302    using algorithm::is_lower;
303    using algorithm::is_upper;
304    using algorithm::is_print;
305    using algorithm::is_punct;
306    using algorithm::is_xdigit;
307    using algorithm::is_any_of;
308    using algorithm::is_from_range;
309
310} // namespace boost
311
312#endif  // BOOST_STRING_PREDICATE_HPP