| // 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_HPP |
| #define BOOST_STRING_CLASSIFICATION_HPP |
| |
| #include <algorithm> |
| #include <locale> |
| #include <boost/range/value_type.hpp> |
| #include <boost/range/as_literal.hpp> |
| #include <boost/algorithm/string/detail/classification.hpp> |
| #include <boost/algorithm/string/predicate_facade.hpp> |
| |
| |
| /*! \file |
| Classification predicates are included in the library to give |
| some more convenience when using algorithms like \c trim() and \c all(). |
| They wrap functionality of STL classification functions ( e.g. \c std::isspace() ) |
| into generic functors. |
| */ |
| |
| namespace boost { |
| namespace algorithm { |
| |
| // classification functor generator -------------------------------------// |
| |
| //! is_classified predicate |
| /*! |
| Construct the \c is_classified predicate. This predicate holds if the input is |
| of specified \c std::ctype category. |
| |
| \param Type A \c std::ctype category |
| \param Loc A locale used for classification |
| \return An instance of the \c is_classified predicate |
| */ |
| inline detail::is_classifiedF |
| is_classified(std::ctype_base::mask Type, const std::locale& Loc=std::locale()) |
| { |
| return detail::is_classifiedF(Type, Loc); |
| } |
| |
| //! is_space predicate |
| /*! |
| Construct the \c is_classified predicate for the \c ctype_base::space category. |
| |
| \param Loc A locale used for classification |
| \return An instance of the \c is_classified predicate |
| */ |
| inline detail::is_classifiedF |
| is_space(const std::locale& Loc=std::locale()) |
| { |
| return detail::is_classifiedF(std::ctype_base::space, Loc); |
| } |
| |
| //! is_alnum predicate |
| /*! |
| Construct the \c is_classified predicate for the \c ctype_base::alnum category. |
| |
| \param Loc A locale used for classification |
| \return An instance of the \c is_classified predicate |
| */ |
| inline detail::is_classifiedF |
| is_alnum(const std::locale& Loc=std::locale()) |
| { |
| return detail::is_classifiedF(std::ctype_base::alnum, Loc); |
| } |
| |
| //! is_alpha predicate |
| /*! |
| Construct the \c is_classified predicate for the \c ctype_base::alpha category. |
| |
| \param Loc A locale used for classification |
| \return An instance of the \c is_classified predicate |
| */ |
| inline detail::is_classifiedF |
| is_alpha(const std::locale& Loc=std::locale()) |
| { |
| return detail::is_classifiedF(std::ctype_base::alpha, Loc); |
| } |
| |
| //! is_cntrl predicate |
| /*! |
| Construct the \c is_classified predicate for the \c ctype_base::cntrl category. |
| |
| \param Loc A locale used for classification |
| \return An instance of the \c is_classified predicate |
| */ |
| inline detail::is_classifiedF |
| is_cntrl(const std::locale& Loc=std::locale()) |
| { |
| return detail::is_classifiedF(std::ctype_base::cntrl, Loc); |
| } |
| |
| //! is_digit predicate |
| /*! |
| Construct the \c is_classified predicate for the \c ctype_base::digit category. |
| |
| \param Loc A locale used for classification |
| \return An instance of the \c is_classified predicate |
| */ |
| inline detail::is_classifiedF |
| is_digit(const std::locale& Loc=std::locale()) |
| { |
| return detail::is_classifiedF(std::ctype_base::digit, Loc); |
| } |
| |
| //! is_graph predicate |
| /*! |
| Construct the \c is_classified predicate for the \c ctype_base::graph category. |
| |
| \param Loc A locale used for classification |
| \return An instance of the \c is_classified predicate |
| */ |
| inline detail::is_classifiedF |
| is_graph(const std::locale& Loc=std::locale()) |
| { |
| return detail::is_classifiedF(std::ctype_base::graph, Loc); |
| } |
| |
| //! is_lower predicate |
| /*! |
| Construct the \c is_classified predicate for the \c ctype_base::lower category. |
| |
| \param Loc A locale used for classification |
| \return An instance of \c is_classified predicate |
| */ |
| inline detail::is_classifiedF |
| is_lower(const std::locale& Loc=std::locale()) |
| { |
| return detail::is_classifiedF(std::ctype_base::lower, Loc); |
| } |
| |
| //! is_print predicate |
| /*! |
| Construct the \c is_classified predicate for the \c ctype_base::print category. |
| |
| \param Loc A locale used for classification |
| \return An instance of the \c is_classified predicate |
| */ |
| inline detail::is_classifiedF |
| is_print(const std::locale& Loc=std::locale()) |
| { |
| return detail::is_classifiedF(std::ctype_base::print, Loc); |
| } |
| |
| //! is_punct predicate |
| /*! |
| Construct the \c is_classified predicate for the \c ctype_base::punct category. |
| |
| \param Loc A locale used for classification |
| \return An instance of the \c is_classified predicate |
| */ |
| inline detail::is_classifiedF |
| is_punct(const std::locale& Loc=std::locale()) |
| { |
| return detail::is_classifiedF(std::ctype_base::punct, Loc); |
| } |
| |
| //! is_upper predicate |
| /*! |
| Construct the \c is_classified predicate for the \c ctype_base::upper category. |
| |
| \param Loc A locale used for classification |
| \return An instance of the \c is_classified predicate |
| */ |
| inline detail::is_classifiedF |
| is_upper(const std::locale& Loc=std::locale()) |
| { |
| return detail::is_classifiedF(std::ctype_base::upper, Loc); |
| } |
| |
| //! is_xdigit predicate |
| /*! |
| Construct the \c is_classified predicate for the \c ctype_base::xdigit category. |
| |
| \param Loc A locale used for classification |
| \return An instance of the \c is_classified predicate |
| */ |
| inline detail::is_classifiedF |
| is_xdigit(const std::locale& Loc=std::locale()) |
| { |
| return detail::is_classifiedF(std::ctype_base::xdigit, Loc); |
| } |
| |
| //! is_any_of predicate |
| /*! |
| Construct the \c is_any_of predicate. The predicate holds if the input |
| is included in the specified set of characters. |
| |
| \param Set A set of characters to be recognized |
| \return An instance of the \c is_any_of predicate |
| */ |
| template<typename RangeT> |
| inline detail::is_any_ofF< |
| BOOST_STRING_TYPENAME range_value<RangeT>::type> |
| is_any_of( const RangeT& Set ) |
| { |
| iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_set(boost::as_literal(Set)); |
| return detail::is_any_ofF<BOOST_STRING_TYPENAME range_value<RangeT>::type>(lit_set); |
| } |
| |
| //! is_from_range predicate |
| /*! |
| Construct the \c is_from_range predicate. The predicate holds if the input |
| is included in the specified range. (i.e. From <= Ch <= To ) |
| |
| \param From The start of the range |
| \param To The end of the range |
| \return An instance of the \c is_from_range predicate |
| */ |
| template<typename CharT> |
| inline detail::is_from_rangeF<CharT> is_from_range(CharT From, CharT To) |
| { |
| return detail::is_from_rangeF<CharT>(From,To); |
| } |
| |
| // predicate combinators ---------------------------------------------------// |
| |
| //! predicate 'and' composition predicate |
| /*! |
| Construct the \c class_and predicate. This predicate can be used |
| to logically combine two classification predicates. \c class_and holds, |
| if both predicates return true. |
| |
| \param Pred1 The first predicate |
| \param Pred2 The second predicate |
| \return An instance of the \c class_and predicate |
| */ |
| template<typename Pred1T, typename Pred2T> |
| inline detail::pred_andF<Pred1T, Pred2T> |
| operator&&( |
| const predicate_facade<Pred1T>& Pred1, |
| const predicate_facade<Pred2T>& Pred2 ) |
| { |
| // Doing the static_cast with the pointer instead of the reference |
| // is a workaround for some compilers which have problems with |
| // static_cast's of template references, i.e. CW8. /grafik/ |
| return detail::pred_andF<Pred1T,Pred2T>( |
| *static_cast<const Pred1T*>(&Pred1), |
| *static_cast<const Pred2T*>(&Pred2) ); |
| } |
| |
| //! predicate 'or' composition predicate |
| /*! |
| Construct the \c class_or predicate. This predicate can be used |
| to logically combine two classification predicates. \c class_or holds, |
| if one of the predicates return true. |
| |
| \param Pred1 The first predicate |
| \param Pred2 The second predicate |
| \return An instance of the \c class_or predicate |
| */ |
| template<typename Pred1T, typename Pred2T> |
| inline detail::pred_orF<Pred1T, Pred2T> |
| operator||( |
| const predicate_facade<Pred1T>& Pred1, |
| const predicate_facade<Pred2T>& Pred2 ) |
| { |
| // Doing the static_cast with the pointer instead of the reference |
| // is a workaround for some compilers which have problems with |
| // static_cast's of template references, i.e. CW8. /grafik/ |
| return detail::pred_orF<Pred1T,Pred2T>( |
| *static_cast<const Pred1T*>(&Pred1), |
| *static_cast<const Pred2T*>(&Pred2)); |
| } |
| |
| //! predicate negation operator |
| /*! |
| Construct the \c class_not predicate. This predicate represents a negation. |
| \c class_or holds if of the predicates return false. |
| |
| \param Pred The predicate to be negated |
| \return An instance of the \c class_not predicate |
| */ |
| template<typename PredT> |
| inline detail::pred_notF<PredT> |
| operator!( const predicate_facade<PredT>& Pred ) |
| { |
| // Doing the static_cast with the pointer instead of the reference |
| // is a workaround for some compilers which have problems with |
| // static_cast's of template references, i.e. CW8. /grafik/ |
| return detail::pred_notF<PredT>(*static_cast<const PredT*>(&Pred)); |
| } |
| |
| } // namespace algorithm |
| |
| // pull names to the boost namespace |
| using algorithm::is_classified; |
| using algorithm::is_space; |
| using algorithm::is_alnum; |
| using algorithm::is_alpha; |
| using algorithm::is_cntrl; |
| using algorithm::is_digit; |
| using algorithm::is_graph; |
| using algorithm::is_lower; |
| using algorithm::is_upper; |
| using algorithm::is_print; |
| using algorithm::is_punct; |
| using algorithm::is_xdigit; |
| using algorithm::is_any_of; |
| using algorithm::is_from_range; |
| |
| } // namespace boost |
| |
| #endif // BOOST_STRING_PREDICATE_HPP |