FM / proto

/usr/include/boost/proto

Name	Size	Mode	Actions
context/	-	0755	rm
detail/	-	0755	rm
functional/	-	0755	rm
transform/	-	0755	rm
args.hpp	3761	0644	edit dl rm
context.hpp	592	0644	edit dl rm
core.hpp	1044	0644	edit dl rm
debug.hpp	10747	0644	edit dl rm
deep_copy.hpp	5396	0644	edit dl rm
domain.hpp	11616	0644	edit dl rm
eval.hpp	4766	0644	edit dl rm
expr.hpp	5427	0644	edit dl rm
extends.hpp	43319	0644	edit dl rm
functional.hpp	576	0644	edit dl rm
fusion.hpp	20934	0644	edit dl rm
generate.hpp	14467	0644	edit dl rm
literal.hpp	3496	0644	edit dl rm
make_expr.hpp	19305	0644	edit dl rm
matches.hpp	34801	0644	edit dl rm
operators.hpp	25833	0644	edit dl rm
proto.hpp	581	0644	edit dl rm
proto_fwd.hpp	29385	0644	edit dl rm
proto_typeof.hpp	6103	0644	edit dl rm
repeat.hpp	11384	0644	edit dl rm
tags.hpp	3960	0644	edit dl rm
traits.hpp	45938	0644	edit dl rm
transform.hpp	950	0644	edit dl rm

Edit: /usr/include/boost/proto/eval.hpp (4766B)

#ifndef BOOST_PROTO_EVAL_HPP_EAN_03_29_2007
#define BOOST_PROTO_EVAL_HPP_EAN_03_29_2007

#include <boost/proto/proto_fwd.hpp> // BOOST_PROTO_CALLABLE
#include <boost/type_traits/remove_reference.hpp>

namespace boost { namespace proto
{

namespace result_of
    {
        /// \brief A metafunction for calculating the return type
        /// of \c proto::eval() given a certain \c Expr and \c Context
        /// types.
        ///
        /// \note The types \c Expr and \c Context should not be
        /// reference types. They may be cv-qualified, but the
        /// cv-qualification on the \c Context parameter is ignored.
        template<typename Expr, typename Context>
        struct eval
        {
            typedef typename Context::template eval<Expr>::result_type type;
        };
    }

namespace functional
    {
        /// \brief A PolymorphicFunctionObject type for
        /// evaluating a given Proto expression with a given
        /// context.
        struct eval
        {
            BOOST_PROTO_CALLABLE()

template<typename Sig>
            struct result;

template<typename This, typename Expr, typename Context>
            struct result<This(Expr, Context)>
            {
                typedef
                    typename proto::result_of::eval<
                        typename remove_reference<Expr>::type
                      , typename remove_reference<Context>::type
                    >::type
                type;
            };

/// \brief Evaluate a given Proto expression with a given
            /// context.
            /// \param expr The Proto expression to evaluate
            /// \param context The context in which the expression should be
            ///     evaluated.
            /// \return <tt>typename Context::template eval<Expr>()(expr, context)</tt>
            template<typename Expr, typename Context>
            typename proto::result_of::eval<Expr, Context>::type
            operator ()(Expr &e, Context &ctx) const
            {
                return typename Context::template eval<Expr>()(e, ctx);
            }

/// \overload
            ///
            template<typename Expr, typename Context>
            typename proto::result_of::eval<Expr, Context>::type
            operator ()(Expr &e, Context const &ctx) const
            {
                return typename Context::template eval<Expr>()(e, ctx);
            }

/// \overload
            ///
            template<typename Expr, typename Context>
            typename proto::result_of::eval<Expr const, Context>::type
            operator ()(Expr const &e, Context &ctx) const
            {
                return typename Context::template eval<Expr const>()(e, ctx);
            }

/// \overload
            ///
            template<typename Expr, typename Context>
            typename proto::result_of::eval<Expr const, Context>::type
            operator ()(Expr const &e, Context const &ctx) const
            {
                return typename Context::template eval<Expr const>()(e, ctx);
            }
        };
    }

/// \brief Evaluate a given Proto expression with a given
    /// context.
    /// \param expr The Proto expression to evaluate
    /// \param context The context in which the expression should be
    ///     evaluated.
    /// \return <tt>typename Context::template eval<Expr>()(expr, context)</tt>
    template<typename Expr, typename Context>
    typename proto::result_of::eval<Expr, Context>::type
    eval(Expr &e, Context &ctx)
    {
        return typename Context::template eval<Expr>()(e, ctx);
    }

/// \overload
    ///
    template<typename Expr, typename Context>
    typename proto::result_of::eval<Expr, Context>::type
    eval(Expr &e, Context const &ctx)
    {
        return typename Context::template eval<Expr>()(e, ctx);
    }

/// \overload
    ///
    template<typename Expr, typename Context>
    typename proto::result_of::eval<Expr const, Context>::type
    eval(Expr const &e, Context &ctx)
    {
        return typename Context::template eval<Expr const>()(e, ctx);
    }

/// \overload
    ///
    template<typename Expr, typename Context>
    typename proto::result_of::eval<Expr const, Context>::type
    eval(Expr const &e, Context const &ctx)
    {
        return typename Context::template eval<Expr const>()(e, ctx);
    }
}}

#endif

/////////////////////////////////////////////////////////////////////////////// /// \file eval.hpp /// Contains the eval() expression evaluator. // // Copyright 2008 Eric Niebler. 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) #ifndef BOOST_PROTO_EVAL_HPP_EAN_03_29_2007 #define BOOST_PROTO_EVAL_HPP_EAN_03_29_2007 #include // BOOST_PROTO_CALLABLE #include namespace boost { namespace proto { namespace result_of { /// \brief A metafunction for calculating the return type /// of \c proto::eval() given a certain \c Expr and \c Context /// types. /// /// \note The types \c Expr and \c Context should not be /// reference types. They may be cv-qualified, but the /// cv-qualification on the \c Context parameter is ignored. template struct eval { typedef typename Context::template eval::result_type type; }; } namespace functional { /// \brief A PolymorphicFunctionObject type for /// evaluating a given Proto expression with a given /// context. struct eval { BOOST_PROTO_CALLABLE() template struct result; template struct result { typedef typename proto::result_of::eval< typename remove_reference::type , typename remove_reference::type >::type type; }; /// \brief Evaluate a given Proto expression with a given /// context. /// \param expr The Proto expression to evaluate /// \param context The context in which the expression should be /// evaluated. /// \return typename Context::template eval()(expr, context) template typename proto::result_of::eval::type operator ()(Expr &e, Context &ctx) const { return typename Context::template eval()(e, ctx); } /// \overload /// template typename proto::result_of::eval::type operator ()(Expr &e, Context const &ctx) const { return typename Context::template eval()(e, ctx); } /// \overload /// template typename proto::result_of::eval::type operator ()(Expr const &e, Context &ctx) const { return typename Context::template eval()(e, ctx); } /// \overload /// template typename proto::result_of::eval::type operator ()(Expr const &e, Context const &ctx) const { return typename Context::template eval()(e, ctx); } }; } /// \brief Evaluate a given Proto expression with a given /// context. /// \param expr The Proto expression to evaluate /// \param context The context in which the expression should be /// evaluated. /// \return typename Context::template eval()(expr, context) template typename proto::result_of::eval::type eval(Expr &e, Context &ctx) { return typename Context::template eval()(e, ctx); } /// \overload /// template typename proto::result_of::eval::type eval(Expr &e, Context const &ctx) { return typename Context::template eval()(e, ctx); } /// \overload /// template typename proto::result_of::eval::type eval(Expr const &e, Context &ctx) { return typename Context::template eval()(e, ctx); } /// \overload /// template typename proto::result_of::eval::type eval(Expr const &e, Context const &ctx) { return typename Context::template eval()(e, ctx); } }} #endif