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

    Copyright (c) 2002-2003 Joel de Guzman

    Copyright (c) 2002 Juan Carlos Arevalo-Baeza

    Copyright (c) 2002-2003 Martin Wille

    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_IF_HPP

#define BOOST_SPIRIT_IF_HPP

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

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

#include <boost/spirit/dynamic/impl/conditions.ipp>

namespace boost { namespace spirit {

    namespace impl {

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

    // if-else-parser, holds two alternative parsers and a conditional functor

    // that selects between them.

    template <typename ParsableTrueT, typename ParsableFalseT, typename CondT>

    struct if_else_parser

        : public condition_evaluator<typename as_parser<CondT>::type>

        , public binary

        <

            typename as_parser<ParsableTrueT>::type,

            typename as_parser<ParsableFalseT>::type,

            parser< if_else_parser<ParsableTrueT, ParsableFalseT, CondT> >

        >

    {

        typedef if_else_parser<ParsableTrueT, ParsableFalseT, CondT>  self_t;

        typedef as_parser<ParsableTrueT>            as_parser_true_t;

        typedef as_parser<ParsableFalseT>           as_parser_false_t;

        typedef typename as_parser_true_t::type     parser_true_t;

        typedef typename as_parser_false_t::type    parser_false_t;

        typedef as_parser<CondT>                    cond_as_parser_t;

        typedef typename cond_as_parser_t::type     condition_t;

        typedef binary<parser_true_t, parser_false_t, parser<self_t> > base_t;

        typedef condition_evaluator<condition_t>                       eval_t;

        if_else_parser

        (

            ParsableTrueT  const& p_true,

            ParsableFalseT const& p_false,

            CondT          const& cond_

        )

            : eval_t(cond_as_parser_t::convert(cond_))

            , base_t

                (

                    as_parser_true_t::convert(p_true),

                    as_parser_false_t::convert(p_false)

                )

        { }

        template <typename ScannerT>

        struct result

        {

            typedef typename match_result<ScannerT, nil_t>::type type;

        };

        template <typename ScannerT>

        typename parser_result<self_t, ScannerT>::type

        parse(ScannerT const& scan) const

        {

            typedef typename parser_result

                <parser_true_t, ScannerT>::type   then_result_t;

            typedef typename parser_result

                <parser_false_t, ScannerT>::type  else_result_t;

            typename ScannerT::iterator_t const  save(scan.first);

            std::ptrdiff_t length = this->evaluate(scan);

            if (length >= 0)

            {

                then_result_t then_result(this->left().parse(scan));

                if (then_result)

                {

                    length += then_result.length();

                    return scan.create_match(std::size_t(length), nil_t(), save, scan.first);

                }

            }

            else

            {

                else_result_t else_result(this->right().parse(scan));

                if (else_result)

                {

                    length = else_result.length();

                    return scan.create_match(std::size_t(length), nil_t(), save, scan.first);

                }

            }

            return scan.no_match();

        }

    };

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

    // if-else-parser generator, takes the false-parser in brackets

    // and returns the if-else-parser.

    template <typename ParsableTrueT, typename CondT>

    struct if_else_parser_gen

    {

        if_else_parser_gen(ParsableTrueT const& p_true_, CondT const& cond_)

            : p_true(p_true_)

            , cond(cond_) {}

        template <typename ParsableFalseT>

        if_else_parser

        <

            ParsableTrueT,

            ParsableFalseT,

            CondT

        >

        operator[](ParsableFalseT const& p_false) const

        {

            return if_else_parser<ParsableTrueT, ParsableFalseT, CondT>

                (

                    p_true,

                    p_false,

                    cond

                );

        }

        ParsableTrueT const &p_true;

        CondT const &cond;

    };

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

    // if-parser, conditionally runs a parser is a functor condition is true.

    // If the condition is fales, it fails the parse.

    // It can optionally become an if-else-parser through the member else_p.

    template <typename ParsableT, typename CondT>

    struct if_parser

        : public condition_evaluator<typename as_parser<CondT>::type>

        , public unary

        <

            typename as_parser<ParsableT>::type,

            parser<if_parser<ParsableT, CondT> > >

    {

        typedef if_parser<ParsableT, CondT>           self_t;

        typedef as_parser<ParsableT>                  as_parser_t;

        typedef typename as_parser_t::type            parser_t;

        typedef as_parser<CondT>                      cond_as_parser_t;

        typedef typename cond_as_parser_t::type       condition_t;

        typedef condition_evaluator<condition_t>      eval_t;

        typedef unary<parser_t, parser<self_t> >      base_t;

        if_parser(ParsableT const& p, CondT const& cond_)

            : eval_t(cond_as_parser_t::convert(cond_))

            , base_t(as_parser_t::convert(p))

            , else_p(p, cond_)

        {}

        template <typename ScannerT>

        struct result

        {

            typedef typename match_result<ScannerT, nil_t>::type type;

        };

        template <typename ScannerT>

        typename parser_result<self_t, ScannerT>::type

        parse(ScannerT const& scan) const

        {

            typedef typename parser_result<parser_t, ScannerT>::type t_result_t;

            typename ScannerT::iterator_t const save(scan.first);

            std::ptrdiff_t length = this->evaluate(scan);

            if (length >= 0)

            {

                t_result_t then_result(this->subject().parse(scan));

                if (then_result)

                {

                    length += then_result.length();

                    return scan.create_match(std::size_t(length), nil_t(), save, scan.first);

                }

                return scan.no_match();

            }

            return scan.empty_match();

        }

        if_else_parser_gen<ParsableT, CondT> else_p;

    };

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

    // if-parser generator, takes the true-parser in brackets and returns the

    // if-parser.

    template <typename CondT>

    struct if_parser_gen

    {

        if_parser_gen(CondT const& cond_) : cond(cond_) {}

        template <typename ParsableT>

        if_parser

        <

            ParsableT,

            CondT

        >

        operator[](ParsableT const& subject) const

        {

            return if_parser<ParsableT, CondT>(subject, cond);

        }

        CondT const &cond;

    };

} // namespace impl

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

// if_p function, returns "if" parser generator

template <typename CondT>

impl::if_parser_gen<CondT>

if_p(CondT const& cond)

{

    return impl::if_parser_gen<CondT>(cond);

}

}} // namespace boost::spirit

#endif // BOOST_SPIRIT_IF_HPP