/*=============================================================================
    Copyright (c) 2001-2007 Joel de Guzman

    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)
==============================================================================*/
#if !defined(BOOST_SPIRIT_RULE_FEB_12_2007_1020AM)
#define BOOST_SPIRIT_RULE_FEB_12_2007_1020AM

#include <boost/spirit/home/support/unused.hpp>
#include <boost/spirit/home/qi/nonterminal/nonterminal.hpp>
#include <boost/spirit/home/qi/nonterminal/grammar_fwd.hpp>
#include <boost/spirit/home/qi/nonterminal/detail/rule.hpp>
#include <boost/spirit/home/qi/nonterminal/detail/error_handler.hpp>
#include <boost/spirit/home/qi/domain.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/type_traits/is_convertible.hpp>

#if defined(BOOST_MSVC)
# pragma warning(push)
# pragma warning(disable: 4355) // 'this' : used in base member initializer list warning
#endif

namespace boost { namespace spirit { namespace qi
{
    namespace detail { struct rule_decorator; }

    template <
        typename Iterator
      , typename T0 = unused_type
      , typename T1 = unused_type
      , typename T2 = unused_type
    >
    struct rule
      : make_nonterminal<rule<Iterator, T0, T1, T2>, T0, T1, T2>::type
    {
        typedef
            make_nonterminal<rule<Iterator, T0, T1, T2>, T0, T1, T2>
        make_nonterminal_;

        typedef typename make_nonterminal_::skipper_type skipper_type;
        typedef typename make_nonterminal_::type base_type;
        typedef Iterator iterator_type;
        typedef rule<Iterator, T0, T1, T2> self_type;

        typedef
            virtual_component_base<
                Iterator
              , typename base_type::context_type
              , skipper_type
            >
        virtual_component;

        typedef intrusive_ptr<virtual_component> pointer_type;

        rule(std::string const& name_ = std::string())
          : name_(name_) {}

        ~rule() {}

        rule(rule const& rhs)
          : ptr(rhs.ptr)
          , name_(rhs.name_)
        {
        }

        rule& operator=(rule const& rhs)
        {
            ptr = rhs.ptr;
            name_ = rhs.name_;
            return *this;
        }

        template <typename Expr>
        rule& operator=(Expr const& xpr)
        {
            typedef spirit::traits::is_component<qi::domain, Expr> is_component;

            // report invalid expression error as early as possible
//             BOOST_MPL_ASSERT_MSG(
//                 is_component::value,
//                 xpr_is_not_convertible_to_a_parser, ());

            // temp workaround for mpl problem
            BOOST_STATIC_ASSERT(is_component::value);

            define(xpr, mpl::false_());
            return *this;
        }

        template <typename Expr>
        friend rule& operator%=(rule& r, Expr const& xpr)
        {
            typedef spirit::traits::is_component<qi::domain, Expr> is_component;

            // report invalid expression error as early as possible
            //~ BOOST_MPL_ASSERT_MSG(
                //~ is_component::value,
                //~ xpr_is_not_convertible_to_a_parser, ());

            // temp workaround for mpl problem
            BOOST_STATIC_ASSERT(is_component::value);

            r.define(xpr, mpl::true_());
            return r;
        }

        self_type alias() const
        {
            self_type result;
            result.define(*this, mpl::false_());
            return result;
        }

        typename
            make_nonterminal_holder<
                nonterminal_object<self_type>
              , self_type
            >::type
        copy() const
        {
            typename
                make_nonterminal_holder<
                    nonterminal_object<self_type>
                  , self_type
                >::type
            result = {{*this}};
            return result;
        }

        std::string const& name() const
        {
            return name_;
        }

        void name(std::string const& str)
        {
            name_ = str;
        }

    private:

        template <typename Iterator_, typename T0_, typename T1_, typename T2_>
        friend struct grammar;

        friend struct detail::rule_decorator;

        template <typename Expr, typename Auto>
        void define(Expr const& xpr, Auto)
        {
            typedef typename
                result_of::as_component<qi::domain, Expr>::type
            component;
            typedef
                detail::virtual_component<
                    Iterator
                  , component
                  , typename base_type::context_type
                  , skipper_type
                  , Auto
                >
            virtual_component;
            ptr = new virtual_component(spirit::as_component(qi::domain(), xpr));
        }

        template <typename Iterator_, typename Context, typename Skipper>
        bool parse(
            Iterator_& first, Iterator_ const& last
          , Context& context, Skipper const& skipper) const
        {
            // If the following line produces a compilation error stating the
            // 4th parameter is not convertible to the expected type, then you
            // are probably trying to use this rule instance with a skipper
            // which is not compatible with the skipper type used while
            // defining the type of this rule instance.
            return ptr->parse(first, last, context, skipper);
        }

        std::string what() const
        {
            if (name_.empty())
            {
                if (ptr)
                {
                    return "unnamed-rule";
                }
                else
                {
                    return "empty-rule";
                }
            }
            else
            {
                return name_;
            }
        }

        friend struct nonterminal_director;
        pointer_type ptr;
        std::string name_;
    };

    // Decoration support: create a new virtual component and link it as
    // first element in the chain of virtual components associated with this
    // rule. Returns the previous topmost virtual component in the chain.
    // We provide support from 1 to 5 arguments.

    namespace detail
    {
        struct rule_decorator
        {
            template <typename Decorator, typename Rule, typename A1>
            typename Rule::pointer_type
            static call(Rule& r, A1 const& a1)
            {
                typename Rule::pointer_type old (r.ptr);
                r.ptr.reset(new Decorator(r.ptr, a1));
                return old;
            }

            template <typename Decorator, typename Rule, typename A1, typename A2>
            typename Rule::pointer_type
            static call(Rule& r, A1 const& a1, A2 const& a2)
            {
                typename Rule::pointer_type old (r.ptr);
                r.ptr.reset(new Decorator(r.ptr, a1, a2));
                return old;
            }

            template <typename Decorator, typename Rule
              , typename A1, typename A2, typename A3
            >
            typename Rule::pointer_type
            static call(Rule& r
              , A1 const& a1, A2 const& a2, A3 const& a3)
            {
                typename Rule::pointer_type old (r.ptr);
                r.ptr.reset(new Decorator(r.ptr, a1, a2, a3));
                return old;
            }

            template <typename Decorator, typename Rule
              , typename A1, typename A2, typename A3, typename A4
            >
            typename Rule::pointer_type
            static call(Rule& r
              , A1 const& a1, A2 const& a2
              , A3 const& a3, A4 const& a4)
            {
                typename Rule::pointer_type old (r.ptr);
                r.ptr.reset(new Decorator(r.ptr, a1, a2, a3, a4));
                return old;
            }

            template <typename Decorator, typename Rule
              , typename A1, typename A2, typename A3, typename A4, typename A5
            >
            typename Rule::pointer_type
            static call(Rule& r
              , A1 const& a1, A2 const& a2
              , A3 const& a3, A4 const& a4, A5 const& a5)
            {
                typename Rule::pointer_type old (r.ptr);
                r.ptr.reset(new Decorator(r.ptr, a1, a2, a3, a4, a5));
                return old;
            }
        };
    }

    template <typename Decorator
      , typename Iterator, typename T0, typename T1, typename T2
      , typename A1>
    typename rule<Iterator, T0, T1, T2>::pointer_type
    decorate(rule<Iterator, T0, T1, T2>& r
      , A1 const& a1)
    {
        return detail::rule_decorator::
            template call<Decorator>(r, a1);
    }

    template <typename Decorator
      , typename Iterator, typename T0, typename T1, typename T2
      , typename A1, typename A2
    >
    typename rule<Iterator, T0, T1, T2>::pointer_type
    decorate(rule<Iterator, T0, T1, T2>& r
      , A1 const& a1, A2 const& a2)
    {
        return detail::rule_decorator::
            template call<Decorator>(r, a1, a2);
    }

    template <typename Decorator
      , typename Iterator, typename T0, typename T1, typename T2
      , typename A1, typename A2, typename A3
    >
    typename rule<Iterator, T0, T1, T2>::pointer_type
    decorate(rule<Iterator, T0, T1, T2>& r
      , A1 const& a1, A2 const& a2, A3 const& a3)
    {
        return detail::rule_decorator::
            template call<Decorator>(r, a1, a2, a3);
    }

    template <typename Decorator
      , typename Iterator, typename T0, typename T1, typename T2
      , typename A1, typename A2, typename A3, typename A4
    >
    typename rule<Iterator, T0, T1, T2>::pointer_type
    decorate(rule<Iterator, T0, T1, T2>& r
      , A1 const& a1, A2 const& a2
      , A3 const& a3, A4 const& a4)
    {
        return detail::rule_decorator::
            template call<Decorator>(r, a1, a2, a3, a4);
    }

    template <typename Decorator
      , typename Iterator, typename T0, typename T1, typename T2
      , typename A1, typename A2, typename A3, typename A4, typename A5
    >
    typename rule<Iterator, T0, T1, T2>::pointer_type
    decorate(rule<Iterator, T0, T1, T2>& r
      , A1 const& a1, A2 const& a2
      , A3 const& a3, A4 const& a4, A5 const& a5)
    {
        return detail::rule_decorator::
            template call<Decorator>(r, a1, a2, a3, a4, a5);
    }

    // Error handling support
    template <
        error_handler_result action
      , typename Iterator, typename T0, typename T1, typename T2
      , typename F>
    void on_error(rule<Iterator, T0, T1, T2>& r, F f)
    {
        typedef
            rule<Iterator, T0, T1, T2>
        rule_type;

        typedef
            detail::error_handler<
                Iterator
              , typename rule_type::base_type::context_type
              , typename rule_type::skipper_type
              , F
              , action>
        error_handler;
        decorate<error_handler>(r, f);
    }

    // Error handling support when <action> is not
    // specified. We will default to <fail>.
    template <typename Iterator, typename T0, typename T1
      , typename T2, typename F>
    void on_error(rule<Iterator, T0, T1, T2>& r, F f)
    {
        on_error<fail>(r, f);
    }

}}}

#if defined(BOOST_MSVC)
# pragma warning(pop)
#endif

#endif