basic_transforms.hpp

Boost provides free peer-reviewed portable C++ source libraries. We emphasize libraries that work

            typedef typename
                proto::result_of::arg<
                    typename proto::result_of::arg_c<Expr, 1>::type
                >::type
            arg1;

            typedef
                traits::make_component<
                    Domain
                  , typename mpl::apply2<DirectorF, function, arg1>::type
                  , typename fusion::result_of::make_cons<arg1>::type
                  , Visitor
                >
            make_component;

            typedef typename make_component::type type;
        };

        template<typename Expr, typename State, typename Visitor>
        typename result<void(Expr, State, Visitor)>::type
        operator ()(Expr const& expr, State const&, Visitor&) const
        {
            typedef typename result<void(Expr, State, Visitor)>::make_component result;
            return result::call(
                fusion::make_cons(proto::arg(proto::arg_c<1>(expr))));
        }
    };

    //  Same as compose_function1, except that the generated component holds 
    //  not only the function argument, but the function tag as well
    template <typename Grammar, typename Domain, typename DirectorF>
    struct compose_function1_full : Grammar
    {
        template<typename Sig>
        struct result;

        template <typename This, typename Expr, typename State, typename Visitor>
        struct result<This(Expr, State, Visitor)>
        {
            typedef typename
                proto::result_of::arg<
                    typename proto::result_of::arg_c<Expr, 0>::type
                >::type
            function;
            typedef typename
                proto::result_of::arg<
                    typename proto::result_of::arg_c<Expr, 1>::type
                >::type
            arg1;

            typedef
                traits::make_component<
                    Domain
                  , typename mpl::apply2<DirectorF, function, arg1>::type
                  , typename fusion::result_of::make_list<function, arg1>::type
                  , Visitor
                >
            make_component;

            typedef typename make_component::type type;
        };

        template<typename Expr, typename State, typename Visitor>
        typename result<void(Expr, State, Visitor)>::type
        operator ()(Expr const& expr, State const& /*state*/, Visitor& /*visitor*/) const
        {
            typedef typename result<void(Expr, State, Visitor)>::make_component result;
            return result::call(fusion::make_list(
                    proto::arg(proto::arg_c<0>(expr)),
                    proto::arg(proto::arg_c<1>(expr))
                ));
        }
    };

    ///////////////////////////////////////////////////////////////////////////
    //  A proto transform that composes a 2-element component
    //  from a 2-arity proto function expression (e.g. f(x, y))
    ///////////////////////////////////////////////////////////////////////////
    template <typename Grammar, typename Domain, typename Director>
    struct compose_function2 : Grammar
    {
        template<typename Sig>
        struct result;

        template <typename This, typename Expr, typename State, typename Visitor>
        struct result<This(Expr, State, Visitor)>
        {
            typedef typename
                proto::result_of::arg<
                    typename proto::result_of::arg_c<Expr, 1>::type
                >::type
            arg1;

            typedef typename
                proto::result_of::arg<
                    typename proto::result_of::arg_c<Expr, 2>::type
                >::type
            arg2;

            typedef
                traits::make_component<
                    Domain, Director
                  , typename fusion::result_of::make_list<arg1, arg2>::type
                  , Visitor
                >
            make_component;

            typedef typename make_component::type type;
        };

        template<typename Expr, typename State, typename Visitor>
        typename result<void(Expr, State, Visitor)>::type
        operator ()(Expr const& expr, State const& /*state*/, Visitor& /*visitor*/) const
        {
            typedef typename result<void(Expr, State, Visitor)>::make_component result;
            return result::call(fusion::make_list(
                proto::arg(proto::arg_c<1>(expr))
              , proto::arg(proto::arg_c<2>(expr))
            ));
        }
    };

    //  Same as compose_function2, except that DirectorF is a meta-function to
    //  be evaluated to get the director
    template <typename Grammar, typename Domain, typename DirectorF>
    struct compose_function2_eval : Grammar
    {
        template<typename Sig>
        struct result;

        template <typename This, typename Expr, typename State, typename Visitor>
        struct result<This(Expr, State, Visitor)>
        {
            typedef typename
                proto::result_of::arg<
                    typename proto::result_of::arg_c<Expr, 0>::type
                >::type
            function;
            typedef typename
                proto::result_of::arg<
                    typename proto::result_of::arg_c<Expr, 1>::type
                >::type
            arg1;
            typedef typename
                proto::result_of::arg<
                    typename proto::result_of::arg_c<Expr, 2>::type
                >::type
            arg2;

            typedef
                traits::make_component<
                    Domain
                  , typename mpl::apply2<DirectorF, function, arg1>::type
                  , typename fusion::result_of::make_list<arg1, arg2>::type
                  , Visitor
                >
            make_component;

            typedef typename make_component::type type;
        };

        template<typename Expr, typename State, typename Visitor>
        typename result<void(Expr, State, Visitor)>::type
        operator ()(Expr const& expr, State const& /*state*/, Visitor& /*visitor*/) const
        {
            typedef typename result<void(Expr, State, Visitor)>::make_component result;
            return result::call(fusion::make_list(
                proto::arg(proto::arg_c<1>(expr))
              , proto::arg(proto::arg_c<2>(expr))
            ));
        }
    };

    ///////////////////////////////////////////////////////////////////////////
    //  A proto transform for directives. The directive (terminal) tag
    //  is pushed into the modifier state (the Visitor).
    ///////////////////////////////////////////////////////////////////////////
    template <typename Grammar>
    struct compose_deep_directive : Grammar
    {
        template<typename Sig>
        struct result;

        template <typename This, typename Expr, typename State, typename Visitor>
        struct result<This(Expr, State, Visitor)>
        {
            typedef typename
                add_modifier<
                    Visitor
                  , typename proto::result_of::arg<
                        typename proto::result_of::arg_c<Expr, 0>::type
                    >::type
                >::type
            modifier_type;

            typedef typename
                Grammar::template result<void(Expr, State, modifier_type)>::type
            type;
        };

        template<typename Expr, typename State, typename Visitor>
        typename result<void(Expr, State, Visitor)>::type
        operator ()(Expr const& expr, State const& state, Visitor&) const
        {
            typename add_modifier<
                Visitor
              , typename proto::result_of::arg<
                    typename proto::result_of::arg_c<Expr, 0>::type
                >::type
            >::type
            modifier;
            return Grammar()(expr, state, modifier);
        }
    };

    ///////////////////////////////////////////////////////////////////////////
    //  A proto transform for creating double-element component meta 
    //  descriptions (proto expressions) usable for defining meta grammars.
    //  This can be used to handle constructs like: 
    //
    //    directive[p]
    //
    ///////////////////////////////////////////////////////////////////////////
    template <typename Grammar, typename Domain, typename Director>
    struct compose_subscript : Grammar
    {
        template<typename Sig>
        struct result;

        template <typename This, typename Expr, typename State, typename Visitor>
        struct result<This(Expr, State, Visitor)>
        {
            // apply all grammar transformations mandated for the whole 
            // expression
            typedef typename
                Grammar::template result<void(Expr, State, Visitor)>::type
            trans;

            // this calculates the type of the directive
            typedef typename proto::result_of::arg_c<trans, 0>::type directive;
            
            // this calculates the type of the embedded expression
            typedef typename proto::result_of::arg_c<trans, 1>::type embedded;
            
            // this is the type of the contained data
            typedef fusion::list<embedded, directive> list_type;

            typedef
                traits::make_component<Domain, Director, list_type, Visitor>
            make_component;

            typedef typename make_component::type type;
        };

        template<typename Expr, typename State, typename Visitor>
        typename result<void(Expr, State, Visitor)>::type
        operator ()(Expr const& expr, State const& state, Visitor& visitor) const
        {
            typedef result<void(Expr, State, Visitor)> apply;
            typedef typename apply::make_component result;
            typedef typename apply::list_type list_type;
            typename apply::trans trans = Grammar()(expr, state, visitor);

            return result::call(
                list_type(proto::arg_c<1>(trans), proto::arg_c<0>(trans)));
        }
    };

    ///////////////////////////////////////////////////////////////////////////
    //  A proto transform for creating double-element component meta 
    //  descriptions (proto expressions) usable for defining meta grammars.
    //  This can be used to handle constructs like: 
    //
    //    directive(a)[p]
    //
    ///////////////////////////////////////////////////////////////////////////
    template <typename Grammar, typename Domain, typename Director>
    struct compose_subscript_function1 : Grammar
    {
        template<typename Sig>
        struct result;

        template <typename This, typename Expr, typename State, typename Visitor>
        struct result<This(Expr, State, Visitor)>
        {
            // apply all grammar transformations mandated for the whole 
            // expression
            typedef typename
                Grammar::template result<void(Expr, State, Visitor)>::type
            trans;

            // this calculates the type of the embedded expression
            typedef typename proto::result_of::arg_c<trans, 1>::type embedded;
            
            // this calculates the type of the argument of the function
            typedef typename
                proto::result_of::arg_c<
                    typename proto::result_of::arg_c<trans, 0>::type, 1
                >::type
            arg1;

            // this is the type of the contained data
            typedef fusion::list<embedded, arg1> list_type;

            typedef
                traits::make_component<
                    Domain, Director,
                    list_type,
                    Visitor
                >
            make_component;

            typedef typename make_component::type type;
        };

        template<typename Expr, typename State, typename Visitor>
        typename result<void(Expr, State, Visitor)>::type
        operator ()(Expr const& expr, State const& state, Visitor& visitor) const
        {
            typedef result<void(Expr, State, Visitor)> apply;
            typedef typename apply::make_component result;
            typedef typename apply::list_type list_type;
            typename apply::trans trans = Grammar()(expr, state, visitor);

            return result::call(list_type(
                proto::arg_c<1>(trans), 
                proto::arg_c<1>(proto::arg_c<0>(trans))));
        }
    };

    ///////////////////////////////////////////////////////////////////////////
    //  A proto transform for creating triple-element component meta 
    //  descriptions (proto expressions) usable for defining meta grammars.
    //  This can be used to handle constructs like: 
    //
    //    directive(a, b)[p]
    //
    ///////////////////////////////////////////////////////////////////////////
    template <typename Grammar, typename Domain, typename Director>
    struct compose_subscript_function2 : Grammar
    {
        template<typename Sig>
        struct result;

        template <typename This, typename Expr, typename State, typename Visitor>
        struct result<This(Expr, State, Visitor)>
        {
            // apply all grammar transformations mandated for the whole 
            // expression
            typedef typename
                Grammar::template result<void(Expr, State, Visitor)>::type
            trans;

            // this calculates the types of the arguments of the function
            typedef typename proto::result_of::arg_c<trans, 0>::type arg0;
            typedef typename proto::result_of::arg_c<arg0, 1>::type arg1;
            typedef typename proto::result_of::arg_c<arg0, 2>::type arg2;

            // this calculates the type of the embedded expression
            typedef typename proto::result_of::arg_c<trans, 1>::type embedded;
            typedef fusion::list<embedded, arg1, arg2> list_type;

            typedef
                traits::make_component<
                    Domain, Director,
                    list_type,
                    Visitor
                >
            make_component;

            typedef typename make_component::type type;
        };

        template<typename Expr, typename State, typename Visitor>
        typename result<void(Expr, State, Visitor)>::type
        operator ()(Expr const& expr, State const& state, Visitor& visitor) const
        {
            typedef result<void(Expr, State, Visitor)> apply;
            typedef typename apply::make_component result;
            typedef typename apply::list_type list_type;
            typename apply::trans trans = Grammar()(expr, state, visitor);
            typename apply::arg0 arg0 = proto::arg_c<0>(trans);

            return result::call(list_type(
                proto::arg_c<1>(trans), proto::arg_c<1>(arg0), 
                proto::arg_c<2>(arg0)));
        }
    };

}}}

#endif