/*=============================================================================

    Copyright (c) 2001-2003 Joel de Guzman

    http://spirit.sourceforge.net/



    Use, modification and distribution is subject to 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)

=============================================================================*/

#ifndef BOOST_SPIRIT_PARAMETRIC_HPP

#define BOOST_SPIRIT_PARAMETRIC_HPP



///////////////////////////////////////////////////////////////////////////////

#include <boost/spirit/core/parser.hpp>

#include <boost/spirit/core/composite/composite.hpp>

#include <boost/spirit/core/primitives/primitives.hpp>



namespace boost { namespace spirit {



    ///////////////////////////////////////////////////////////////////////////

    //

    //  f_chlit class [ functional version of chlit ]

    //

    ///////////////////////////////////////////////////////////////////////////

    template <typename ChGenT>

    struct f_chlit : public char_parser<f_chlit<ChGenT> >

    {

        f_chlit(ChGenT chgen_)

        : chgen(chgen_) {}



        template <typename T>

        bool test(T ch) const

        { return ch == chgen(); }



        ChGenT   chgen;

    };



    template <typename ChGenT>

    inline f_chlit<ChGenT>

    f_ch_p(ChGenT chgen)

    { return f_chlit<ChGenT>(chgen); }



    ///////////////////////////////////////////////////////////////////////////

    //

    //  f_range class [ functional version of range ]

    //

    ///////////////////////////////////////////////////////////////////////////

    template <typename ChGenAT, typename ChGenBT>

    struct f_range : public char_parser<f_range<ChGenAT, ChGenBT> >

    {

        f_range(ChGenAT first_, ChGenBT last_)

        : first(first_), last(last_)

        {}



        template <typename T>

        bool test(T ch) const

        {

            BOOST_SPIRIT_ASSERT(first() <= last());

            return (ch >= first()) && (ch <= last());

        }



        ChGenAT first;

        ChGenBT last;

    };



    template <typename ChGenAT, typename ChGenBT>

    inline f_range<ChGenAT, ChGenBT>

    f_range_p(ChGenAT first, ChGenBT last)

    { return f_range<ChGenAT, ChGenBT>(first, last); }



    ///////////////////////////////////////////////////////////////////////////

    //

    //  f_chseq class [ functional version of chseq ]

    //

    ///////////////////////////////////////////////////////////////////////////

    template <typename IterGenAT, typename IterGenBT>

    class f_chseq : public parser<f_chseq<IterGenAT, IterGenBT> >

    {

    public:



        typedef f_chseq<IterGenAT, IterGenBT> self_t;



        f_chseq(IterGenAT first_, IterGenBT last_)

        : first(first_), last(last_) {}



        template <typename ScannerT>

        typename parser_result<self_t, ScannerT>::type

        parse(ScannerT const& scan) const

        {

            typedef typename parser_result<self_t, ScannerT>::type result_t;

            return impl::string_parser_parse<result_t>(first(), last(), scan);

        }



    private:



        IterGenAT first;

        IterGenBT last;

    };



    template <typename IterGenAT, typename IterGenBT>

    inline f_chseq<IterGenAT, IterGenBT>

    f_chseq_p(IterGenAT first, IterGenBT last)

    { return f_chseq<IterGenAT, IterGenBT>(first, last); }



    ///////////////////////////////////////////////////////////////////////////

    //

    //  f_strlit class [ functional version of strlit ]

    //

    ///////////////////////////////////////////////////////////////////////////

    template <typename IterGenAT, typename IterGenBT>

    class f_strlit : public parser<f_strlit<IterGenAT, IterGenBT> >

    {

    public:



        typedef f_strlit<IterGenAT, IterGenBT> self_t;



        f_strlit(IterGenAT first, IterGenBT last)

        : seq(first, last) {}



        template <typename ScannerT>

        typename parser_result<self_t, ScannerT>::type

        parse(ScannerT const& scan) const

        {

            typedef typename parser_result<self_t, ScannerT>::type result_t;

            return impl::contiguous_parser_parse<result_t>

                (seq, scan, scan);

        }



    private:



        f_chseq<IterGenAT, IterGenBT> seq;

    };



    template <typename IterGenAT, typename IterGenBT>

    inline f_strlit<IterGenAT, IterGenBT>

    f_str_p(IterGenAT first, IterGenBT last)

    { return f_strlit<IterGenAT, IterGenBT>(first, last); }



}} // namespace boost::spirit



#endif

