boost/algorithm/string/classification.hpp
// 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