313 lines
12 KiB
Plaintext
313 lines
12 KiB
Plaintext
// 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
|