//  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(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