Added boost header
This commit is contained in:
Christophe Riccio
165
test/external/boost/proto/args.hpp
vendored
Normal file
165
test/external/boost/proto/args.hpp
vendored
Normal file
@@ -0,0 +1,165 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file args.hpp
|
||||
/// Contains definition of \c term\<\>, \c list1\<\>, \c list2\<\>, ...
|
||||
/// class templates.
|
||||
//
|
||||
// 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_ARGS_HPP_EAN_04_01_2005
|
||||
#define BOOST_PROTO_ARGS_HPP_EAN_04_01_2005
|
||||
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/arithmetic/dec.hpp>
|
||||
#include <boost/preprocessor/iteration/iterate.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
|
||||
#include <boost/type_traits/is_function.hpp>
|
||||
#include <boost/type_traits/is_abstract.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/mpl/or.hpp>
|
||||
#include <boost/mpl/void.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
// All classes derived from std::ios_base have these public nested types,
|
||||
// and are non-copyable. This is an imperfect test, but it's the best we
|
||||
// we can do.
|
||||
template<typename T>
|
||||
yes_type check_is_iostream(
|
||||
typename T::failure *
|
||||
, typename T::Init *
|
||||
, typename T::fmtflags *
|
||||
, typename T::iostate *
|
||||
, typename T::openmode *
|
||||
, typename T::seekdir *
|
||||
);
|
||||
|
||||
template<typename T>
|
||||
no_type check_is_iostream(...);
|
||||
|
||||
template<typename T>
|
||||
struct is_iostream
|
||||
{
|
||||
static bool const value = sizeof(yes_type) == sizeof(check_is_iostream<T>(0,0,0,0,0,0));
|
||||
typedef mpl::bool_<value> type;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
// This should be a customization point. And it serves the same purpose
|
||||
// as the is_noncopyable trait in Boost.Foreach.
|
||||
template<typename T>
|
||||
struct ref_only
|
||||
: mpl::or_<
|
||||
is_function<T>
|
||||
, is_abstract<T>
|
||||
, is_iostream<T>
|
||||
>
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<typename Expr>
|
||||
struct expr_traits
|
||||
{
|
||||
typedef Expr value_type;
|
||||
typedef Expr &reference;
|
||||
typedef Expr const &const_reference;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<typename Expr>
|
||||
struct expr_traits<Expr &>
|
||||
{
|
||||
typedef Expr value_type;
|
||||
typedef Expr &reference;
|
||||
typedef Expr &const_reference;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<typename Expr>
|
||||
struct expr_traits<Expr const &>
|
||||
{
|
||||
typedef Expr value_type;
|
||||
typedef Expr const &reference;
|
||||
typedef Expr const &const_reference;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<typename T>
|
||||
struct term_traits
|
||||
{
|
||||
typedef T value_type;
|
||||
typedef T &reference;
|
||||
typedef T const &const_reference;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<typename T>
|
||||
struct term_traits<T &>
|
||||
{
|
||||
typedef typename mpl::if_c<ref_only<T>::value, T &, T>::type value_type;
|
||||
typedef T &reference;
|
||||
typedef T &const_reference;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<typename T>
|
||||
struct term_traits<T const &>
|
||||
{
|
||||
typedef T value_type;
|
||||
typedef T const &reference;
|
||||
typedef T const &const_reference;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<typename T, std::size_t N>
|
||||
struct term_traits<T (&)[N]>
|
||||
{
|
||||
typedef T value_type[N];
|
||||
typedef T (&reference)[N];
|
||||
typedef T (&const_reference)[N];
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<typename T, std::size_t N>
|
||||
struct term_traits<T const (&)[N]>
|
||||
{
|
||||
typedef T value_type[N];
|
||||
typedef T const (&reference)[N];
|
||||
typedef T const (&const_reference)[N];
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<typename T, std::size_t N>
|
||||
struct term_traits<T[N]>
|
||||
{
|
||||
typedef T value_type[N];
|
||||
typedef T (&reference)[N];
|
||||
typedef T const (&const_reference)[N];
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<typename T, std::size_t N>
|
||||
struct term_traits<T const[N]>
|
||||
{
|
||||
typedef T value_type[N];
|
||||
typedef T const (&reference)[N];
|
||||
typedef T const (&const_reference)[N];
|
||||
};
|
||||
}
|
||||
|
||||
namespace argsns_
|
||||
{
|
||||
// This is where term and all the different listN templates are defined
|
||||
#include <boost/proto/detail/args.hpp>
|
||||
}
|
||||
|
||||
}}
|
||||
|
||||
#endif
|
||||
|
||||
16
test/external/boost/proto/context.hpp
vendored
Normal file
16
test/external/boost/proto/context.hpp
vendored
Normal file
@@ -0,0 +1,16 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file context.hpp
|
||||
/// Includes all the context classes in the context/ sub-directory.
|
||||
//
|
||||
// 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_CONTEXT_HPP_EAN_06_23_2007
|
||||
#define BOOST_PROTO_CONTEXT_HPP_EAN_06_23_2007
|
||||
|
||||
#include <boost/proto/context/null.hpp>
|
||||
#include <boost/proto/context/default.hpp>
|
||||
#include <boost/proto/context/callable.hpp>
|
||||
|
||||
#endif
|
||||
229
test/external/boost/proto/context/callable.hpp
vendored
Normal file
229
test/external/boost/proto/context/callable.hpp
vendored
Normal file
@@ -0,0 +1,229 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file callable.hpp
|
||||
/// Definintion of callable_context\<\>, an evaluation context for
|
||||
/// proto::eval() that explodes each node and calls the derived context
|
||||
/// type with the expressions constituents. If the derived context doesn't
|
||||
/// have an overload that handles this node, fall back to some other
|
||||
/// context.
|
||||
//
|
||||
// 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_CONTEXT_CALLABLE_HPP_EAN_06_23_2007
|
||||
#define BOOST_PROTO_CONTEXT_CALLABLE_HPP_EAN_06_23_2007
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/iteration/iterate.hpp>
|
||||
#include <boost/preprocessor/facilities/intercept.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
|
||||
#include <boost/preprocessor/arithmetic/inc.hpp>
|
||||
#include <boost/preprocessor/selection/max.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/utility/result_of.hpp>
|
||||
#include <boost/type_traits/remove_cv.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/traits.hpp> // for child_c
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
template<typename Context>
|
||||
struct callable_context_wrapper
|
||||
: remove_cv<Context>::type
|
||||
{
|
||||
callable_context_wrapper();
|
||||
typedef private_type_ fun_type(...);
|
||||
operator fun_type *() const;
|
||||
private:
|
||||
callable_context_wrapper &operator =(callable_context_wrapper const &);
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
yes_type check_is_expr_handled(T const &);
|
||||
|
||||
no_type check_is_expr_handled(private_type_ const &);
|
||||
|
||||
template<typename Expr, typename Context, long Arity = Expr::proto_arity_c>
|
||||
struct is_expr_handled;
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct is_expr_handled<Expr, Context, 0>
|
||||
{
|
||||
static callable_context_wrapper<Context> &sctx_;
|
||||
static Expr &sexpr_;
|
||||
static typename Expr::proto_tag &stag_;
|
||||
|
||||
static const bool value =
|
||||
sizeof(yes_type) ==
|
||||
sizeof(
|
||||
detail::check_is_expr_handled(
|
||||
(sctx_(stag_, proto::value(sexpr_)), 0)
|
||||
)
|
||||
);
|
||||
|
||||
typedef mpl::bool_<value> type;
|
||||
};
|
||||
}
|
||||
|
||||
namespace context
|
||||
{
|
||||
/// \brief A BinaryFunction that accepts a Proto expression and a
|
||||
/// callable context and calls the context with the expression tag
|
||||
/// and children as arguments, effectively fanning the expression
|
||||
/// out.
|
||||
///
|
||||
/// <tt>callable_eval\<\></tt> requires that \c Context is a
|
||||
/// PolymorphicFunctionObject that can be invoked with \c Expr's
|
||||
/// tag and children as expressions, as follows:
|
||||
///
|
||||
/// \code
|
||||
/// context(Expr::proto_tag(), child_c<0>(expr), child_c<1>(expr), ...)
|
||||
/// \endcode
|
||||
template<
|
||||
typename Expr
|
||||
, typename Context
|
||||
, long Arity // = Expr::proto_arity_c
|
||||
>
|
||||
struct callable_eval
|
||||
{};
|
||||
|
||||
/// \brief A BinaryFunction that accepts a Proto expression and a
|
||||
/// callable context and calls the context with the expression tag
|
||||
/// and children as arguments, effectively fanning the expression
|
||||
/// out.
|
||||
///
|
||||
/// <tt>callable_eval\<\></tt> requires that \c Context is a
|
||||
/// PolymorphicFunctionObject that can be invoked with \c Expr's
|
||||
/// tag and children as expressions, as follows:
|
||||
///
|
||||
/// \code
|
||||
/// context(Expr::proto_tag(), value(expr))
|
||||
/// \endcode
|
||||
template<typename Expr, typename Context>
|
||||
struct callable_eval<Expr, Context, 0>
|
||||
{
|
||||
typedef typename proto::result_of::value<Expr const &>::type value_type;
|
||||
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
Context(typename Expr::proto_tag, value_type)
|
||||
>::type
|
||||
result_type;
|
||||
|
||||
/// \param expr The current expression
|
||||
/// \param context The callable evaluation context
|
||||
/// \return <tt>context(Expr::proto_tag(), value(expr))</tt>
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return context(typename Expr::proto_tag(), proto::value(expr));
|
||||
}
|
||||
};
|
||||
|
||||
/// \brief An evaluation context adaptor that makes authoring a
|
||||
/// context a simple matter of writing function overloads, rather
|
||||
/// then writing template specializations.
|
||||
///
|
||||
/// <tt>callable_context\<\></tt> is a base class that implements
|
||||
/// the context protocol by passing fanned-out expression nodes to
|
||||
/// the derived context, making it easy to customize the handling
|
||||
/// of expression types by writing function overloads. Only those
|
||||
/// expression types needing special handling require explicit
|
||||
/// handling. All others are dispatched to a user-specified
|
||||
/// default context, \c DefaultCtx.
|
||||
///
|
||||
/// <tt>callable_context\<\></tt> is defined simply as:
|
||||
///
|
||||
/// \code
|
||||
/// template<typename Context, typename DefaultCtx = default_context>
|
||||
/// struct callable_context
|
||||
/// {
|
||||
/// template<typename Expr, typename ThisContext = Context>
|
||||
/// struct eval
|
||||
/// : mpl::if_<
|
||||
/// is_expr_handled_<Expr, Context> // For exposition
|
||||
/// , callable_eval<Expr, ThisContext>
|
||||
/// , typename DefaultCtx::template eval<Expr, Context>
|
||||
/// >::type
|
||||
/// {};
|
||||
/// };
|
||||
/// \endcode
|
||||
///
|
||||
/// The Boolean metafunction <tt>is_expr_handled_\<\></tt> uses
|
||||
/// metaprogramming tricks to determine whether \c Context has
|
||||
/// an overloaded function call operator that accepts the
|
||||
/// fanned-out constituents of an expression of type \c Expr.
|
||||
/// If so, the handling of the expression is dispatched to
|
||||
/// <tt>callable_eval\<\></tt>. If not, it is dispatched to
|
||||
/// the user-specified \c DefaultCtx.
|
||||
///
|
||||
/// Below is an example of how to use <tt>callable_context\<\></tt>:
|
||||
///
|
||||
/// \code
|
||||
/// // An evaluation context that increments all
|
||||
/// // integer terminals in-place.
|
||||
/// struct increment_ints
|
||||
/// : callable_context<
|
||||
/// increment_ints const // derived context
|
||||
/// , null_context const // fall-back context
|
||||
/// >
|
||||
/// {
|
||||
/// typedef void result_type;
|
||||
///
|
||||
/// // Handle int terminals here:
|
||||
/// void operator()(proto::tag::terminal, int &i) const
|
||||
/// {
|
||||
/// ++i;
|
||||
/// }
|
||||
/// };
|
||||
/// \endcode
|
||||
///
|
||||
/// With \c increment_ints, we can do the following:
|
||||
///
|
||||
/// \code
|
||||
/// literal<int> i = 0, j = 10;
|
||||
/// proto::eval( i - j * 3.14, increment_ints() );
|
||||
///
|
||||
/// assert( i.get() == 1 && j.get() == 11 );
|
||||
/// \endcode
|
||||
template<
|
||||
typename Context
|
||||
, typename DefaultCtx // = default_context
|
||||
>
|
||||
struct callable_context
|
||||
{
|
||||
/// A BinaryFunction that accepts an \c Expr and a
|
||||
/// \c Context, and either fans out the expression and passes
|
||||
/// it to the context, or else hands off the expression to
|
||||
/// \c DefaultCtx.
|
||||
///
|
||||
/// If \c Context is a PolymorphicFunctionObject such that
|
||||
/// it can be invoked with the tag and children of \c Expr,
|
||||
/// as <tt>ctx(Expr::proto_tag(), child_c\<0\>(expr), child_c\<1\>(expr)...)</tt>,
|
||||
/// then <tt>eval\<Expr, ThisContext\></tt> inherits from
|
||||
/// <tt>callable_eval\<Expr, ThisContext\></tt>. Otherwise,
|
||||
/// <tt>eval\<Expr, ThisContext\></tt> inherits from
|
||||
/// <tt>DefaultCtx::eval\<Expr, Context\></tt>.
|
||||
template<typename Expr, typename ThisContext = Context>
|
||||
struct eval
|
||||
: mpl::if_c<
|
||||
detail::is_expr_handled<Expr, Context>::value
|
||||
, callable_eval<Expr, ThisContext>
|
||||
, typename DefaultCtx::template eval<Expr, Context>
|
||||
>::type
|
||||
{};
|
||||
};
|
||||
}
|
||||
|
||||
#include <boost/proto/context/detail/callable_eval.hpp>
|
||||
|
||||
}}
|
||||
|
||||
#endif
|
||||
409
test/external/boost/proto/context/default.hpp
vendored
Normal file
409
test/external/boost/proto/context/default.hpp
vendored
Normal file
@@ -0,0 +1,409 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file default.hpp
|
||||
/// Definintion of default_context, a default evaluation context for
|
||||
/// proto::eval() that uses Boost.Typeof to deduce return types
|
||||
/// of the built-in operators.
|
||||
//
|
||||
// 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_CONTEXT_DEFAULT_HPP_EAN_01_08_2007
|
||||
#define BOOST_PROTO_CONTEXT_DEFAULT_HPP_EAN_01_08_2007
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/preprocessor/arithmetic/add.hpp>
|
||||
#include <boost/preprocessor/arithmetic/sub.hpp>
|
||||
#include <boost/preprocessor/iteration/iterate.hpp>
|
||||
#include <boost/preprocessor/repetition/enum.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_shifted.hpp>
|
||||
#include <boost/utility/result_of.hpp>
|
||||
#include <boost/type_traits/is_const.hpp>
|
||||
#include <boost/type_traits/is_function.hpp>
|
||||
#include <boost/type_traits/remove_reference.hpp>
|
||||
#include <boost/type_traits/is_member_pointer.hpp>
|
||||
#include <boost/type_traits/is_member_object_pointer.hpp>
|
||||
#include <boost/type_traits/is_member_function_pointer.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/tags.hpp>
|
||||
#include <boost/proto/eval.hpp>
|
||||
#include <boost/proto/traits.hpp> // for proto::child_c()
|
||||
#include <boost/proto/detail/decltype.hpp>
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define UNREF(x) typename boost::remove_reference<x>::type
|
||||
|
||||
namespace context
|
||||
{
|
||||
template<
|
||||
typename Expr
|
||||
, typename Context
|
||||
, typename Tag // = typename Expr::proto_tag
|
||||
, long Arity // = Expr::proto_arity_c
|
||||
>
|
||||
struct default_eval
|
||||
{};
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct default_eval<Expr, Context, tag::terminal, 0>
|
||||
{
|
||||
typedef
|
||||
typename proto::result_of::value<Expr &>::type
|
||||
result_type;
|
||||
|
||||
result_type operator ()(Expr &expr, Context &) const
|
||||
{
|
||||
return proto::value(expr);
|
||||
}
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_UNARY_DEFAULT_EVAL(OP, TAG, MAKE) \
|
||||
template<typename Expr, typename Context> \
|
||||
struct default_eval<Expr, Context, TAG, 1> \
|
||||
{ \
|
||||
private: \
|
||||
typedef typename proto::result_of::child_c<Expr, 0>::type e0; \
|
||||
typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; \
|
||||
public: \
|
||||
BOOST_PROTO_DECLTYPE_(OP proto::detail::MAKE<r0>(), result_type) \
|
||||
result_type operator ()(Expr &expr, Context &ctx) const \
|
||||
{ \
|
||||
return OP proto::eval(proto::child_c<0>(expr), ctx); \
|
||||
} \
|
||||
}; \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_BINARY_DEFAULT_EVAL(OP, TAG, LMAKE, RMAKE) \
|
||||
template<typename Expr, typename Context> \
|
||||
struct default_eval<Expr, Context, TAG, 2> \
|
||||
{ \
|
||||
private: \
|
||||
typedef typename proto::result_of::child_c<Expr, 0>::type e0; \
|
||||
typedef typename proto::result_of::child_c<Expr, 1>::type e1; \
|
||||
typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; \
|
||||
typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1; \
|
||||
public: \
|
||||
BOOST_PROTO_DECLTYPE_( \
|
||||
proto::detail::LMAKE<r0>() OP proto::detail::RMAKE<r1>() \
|
||||
, result_type \
|
||||
) \
|
||||
result_type operator ()(Expr &expr, Context &ctx) const \
|
||||
{ \
|
||||
return proto::eval( \
|
||||
proto::child_c<0>(expr), ctx) OP proto::eval(proto::child_c<1>(expr) \
|
||||
, ctx \
|
||||
); \
|
||||
} \
|
||||
}; \
|
||||
/**/
|
||||
|
||||
BOOST_PROTO_UNARY_DEFAULT_EVAL(+, proto::tag::unary_plus, make)
|
||||
BOOST_PROTO_UNARY_DEFAULT_EVAL(-, proto::tag::negate, make)
|
||||
BOOST_PROTO_UNARY_DEFAULT_EVAL(*, proto::tag::dereference, make)
|
||||
BOOST_PROTO_UNARY_DEFAULT_EVAL(~, proto::tag::complement, make)
|
||||
BOOST_PROTO_UNARY_DEFAULT_EVAL(&, proto::tag::address_of, make)
|
||||
BOOST_PROTO_UNARY_DEFAULT_EVAL(!, proto::tag::logical_not, make)
|
||||
BOOST_PROTO_UNARY_DEFAULT_EVAL(++, proto::tag::pre_inc, make_mutable)
|
||||
BOOST_PROTO_UNARY_DEFAULT_EVAL(--, proto::tag::pre_dec, make_mutable)
|
||||
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(<<, proto::tag::shift_left, make_mutable, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(>>, proto::tag::shift_right, make_mutable, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(*, proto::tag::multiplies, make, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(/, proto::tag::divides, make, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(%, proto::tag::modulus, make, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(+, proto::tag::plus, make, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(-, proto::tag::minus, make, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(<, proto::tag::less, make, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(>, proto::tag::greater, make, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(<=, proto::tag::less_equal, make, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(>=, proto::tag::greater_equal, make, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(==, proto::tag::equal_to, make, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(!=, proto::tag::not_equal_to, make, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(||, proto::tag::logical_or, make, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(&&, proto::tag::logical_and, make, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(&, proto::tag::bitwise_and, make, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(|, proto::tag::bitwise_or, make, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(^, proto::tag::bitwise_xor, make, make)
|
||||
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(=, proto::tag::assign, make_mutable, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(<<=, proto::tag::shift_left_assign, make_mutable, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(>>=, proto::tag::shift_right_assign, make_mutable, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(*=, proto::tag::multiplies_assign, make_mutable, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(/=, proto::tag::divides_assign, make_mutable, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(%=, proto::tag::modulus_assign, make_mutable, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(+=, proto::tag::plus_assign, make_mutable, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(-=, proto::tag::minus_assign, make_mutable, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(&=, proto::tag::bitwise_and_assign, make_mutable, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(|=, proto::tag::bitwise_or_assign, make_mutable, make)
|
||||
BOOST_PROTO_BINARY_DEFAULT_EVAL(^=, proto::tag::bitwise_xor_assign, make_mutable, make)
|
||||
|
||||
#undef BOOST_PROTO_UNARY_DEFAULT_EVAL
|
||||
#undef BOOST_PROTO_BINARY_DEFAULT_EVAL
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<typename Expr, typename Context>
|
||||
struct is_member_function_eval
|
||||
: is_member_function_pointer<
|
||||
typename detail::uncvref<
|
||||
typename proto::result_of::eval<
|
||||
typename remove_reference<
|
||||
typename proto::result_of::child_c<Expr, 1>::type
|
||||
>::type
|
||||
, Context
|
||||
>::type
|
||||
>::type
|
||||
>
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<typename Expr, typename Context, bool IsMemFunCall>
|
||||
struct memfun_eval
|
||||
{
|
||||
private:
|
||||
typedef typename result_of::child_c<Expr, 0>::type e0;
|
||||
typedef typename result_of::child_c<Expr, 1>::type e1;
|
||||
typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;
|
||||
typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1;
|
||||
public:
|
||||
typedef typename detail::mem_ptr_fun<r0, r1>::result_type result_type;
|
||||
result_type operator ()(Expr &expr, Context &ctx) const
|
||||
{
|
||||
return detail::mem_ptr_fun<r0, r1>()(
|
||||
proto::eval(proto::child_c<0>(expr), ctx)
|
||||
, proto::eval(proto::child_c<1>(expr), ctx)
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<typename Expr, typename Context>
|
||||
struct memfun_eval<Expr, Context, true>
|
||||
{
|
||||
private:
|
||||
typedef typename result_of::child_c<Expr, 0>::type e0;
|
||||
typedef typename result_of::child_c<Expr, 1>::type e1;
|
||||
typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;
|
||||
typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1;
|
||||
public:
|
||||
typedef detail::memfun<r0, r1> result_type;
|
||||
result_type const operator ()(Expr &expr, Context &ctx) const
|
||||
{
|
||||
return detail::memfun<r0, r1>(
|
||||
proto::eval(proto::child_c<0>(expr), ctx)
|
||||
, proto::eval(proto::child_c<1>(expr), ctx)
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct default_eval<Expr, Context, tag::mem_ptr, 2>
|
||||
: memfun_eval<Expr, Context, is_member_function_eval<Expr, Context>::value>
|
||||
{};
|
||||
|
||||
// Handle post-increment specially.
|
||||
template<typename Expr, typename Context>
|
||||
struct default_eval<Expr, Context, proto::tag::post_inc, 1>
|
||||
{
|
||||
private:
|
||||
typedef typename proto::result_of::child_c<Expr, 0>::type e0;
|
||||
typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;
|
||||
public:
|
||||
BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() ++, result_type)
|
||||
result_type operator ()(Expr &expr, Context &ctx) const
|
||||
{
|
||||
return proto::eval(proto::child_c<0>(expr), ctx) ++;
|
||||
}
|
||||
};
|
||||
|
||||
// Handle post-decrement specially.
|
||||
template<typename Expr, typename Context>
|
||||
struct default_eval<Expr, Context, proto::tag::post_dec, 1>
|
||||
{
|
||||
private:
|
||||
typedef typename proto::result_of::child_c<Expr, 0>::type e0;
|
||||
typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;
|
||||
public:
|
||||
BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() --, result_type)
|
||||
result_type operator ()(Expr &expr, Context &ctx) const
|
||||
{
|
||||
return proto::eval(proto::child_c<0>(expr), ctx) --;
|
||||
}
|
||||
};
|
||||
|
||||
// Handle subscript specially.
|
||||
template<typename Expr, typename Context>
|
||||
struct default_eval<Expr, Context, proto::tag::subscript, 2>
|
||||
{
|
||||
private:
|
||||
typedef typename proto::result_of::child_c<Expr, 0>::type e0;
|
||||
typedef typename proto::result_of::child_c<Expr, 1>::type e1;
|
||||
typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;
|
||||
typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1;
|
||||
public:
|
||||
BOOST_PROTO_DECLTYPE_(proto::detail::make_subscriptable<r0>()[proto::detail::make<r1>()], result_type)
|
||||
result_type operator ()(Expr &expr, Context &ctx) const
|
||||
{
|
||||
return proto::eval(proto::child_c<0>(expr), ctx)[proto::eval(proto::child_c<1>(expr), ctx)];
|
||||
}
|
||||
};
|
||||
|
||||
// Handle if_else_ specially.
|
||||
template<typename Expr, typename Context>
|
||||
struct default_eval<Expr, Context, proto::tag::if_else_, 3>
|
||||
{
|
||||
private:
|
||||
typedef typename proto::result_of::child_c<Expr, 0>::type e0;
|
||||
typedef typename proto::result_of::child_c<Expr, 1>::type e1;
|
||||
typedef typename proto::result_of::child_c<Expr, 2>::type e2;
|
||||
typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;
|
||||
typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1;
|
||||
typedef typename proto::result_of::eval<UNREF(e2), Context>::type r2;
|
||||
public:
|
||||
BOOST_PROTO_DECLTYPE_(
|
||||
proto::detail::make<r0>()
|
||||
? proto::detail::make<r1>()
|
||||
: proto::detail::make<r2>()
|
||||
, result_type
|
||||
)
|
||||
result_type operator ()(Expr &expr, Context &ctx) const
|
||||
{
|
||||
return proto::eval(proto::child_c<0>(expr), ctx)
|
||||
? proto::eval(proto::child_c<1>(expr), ctx)
|
||||
: proto::eval(proto::child_c<2>(expr), ctx);
|
||||
}
|
||||
};
|
||||
|
||||
// Handle comma specially.
|
||||
template<typename Expr, typename Context>
|
||||
struct default_eval<Expr, Context, proto::tag::comma, 2>
|
||||
{
|
||||
private:
|
||||
typedef typename proto::result_of::child_c<Expr, 0>::type e0;
|
||||
typedef typename proto::result_of::child_c<Expr, 1>::type e1;
|
||||
typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;
|
||||
typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1;
|
||||
public:
|
||||
typedef typename proto::detail::comma_result<r0, r1>::type result_type;
|
||||
result_type operator ()(Expr &expr, Context &ctx) const
|
||||
{
|
||||
return proto::eval(proto::child_c<0>(expr), ctx), proto::eval(proto::child_c<1>(expr), ctx);
|
||||
}
|
||||
};
|
||||
|
||||
// Handle function specially
|
||||
#define BOOST_PROTO_DEFAULT_EVAL_TYPE(Z, N, DATA) \
|
||||
typename proto::result_of::eval< \
|
||||
typename remove_reference< \
|
||||
typename proto::result_of::child_c<DATA, N>::type \
|
||||
>::type \
|
||||
, Context \
|
||||
>::type \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_DEFAULT_EVAL(Z, N, DATA) \
|
||||
proto::eval(proto::child_c<N>(DATA), context) \
|
||||
/**/
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct default_eval<Expr, Context, proto::tag::function, 1>
|
||||
{
|
||||
typedef
|
||||
typename proto::detail::result_of_fixup<
|
||||
BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr)
|
||||
>::type
|
||||
function_type;
|
||||
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<function_type()>::type
|
||||
result_type;
|
||||
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)();
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct default_eval<Expr, Context, proto::tag::function, 2>
|
||||
{
|
||||
typedef
|
||||
typename proto::detail::result_of_fixup<
|
||||
BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr)
|
||||
>::type
|
||||
function_type;
|
||||
|
||||
typedef
|
||||
typename detail::result_of_<
|
||||
function_type(BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 1, Expr))
|
||||
>::type
|
||||
result_type;
|
||||
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return this->invoke(
|
||||
expr
|
||||
, context
|
||||
, is_member_function_pointer<function_type>()
|
||||
, is_member_object_pointer<function_type>()
|
||||
);
|
||||
}
|
||||
|
||||
private:
|
||||
result_type invoke(Expr &expr, Context &context, mpl::false_, mpl::false_) const
|
||||
{
|
||||
return BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)(BOOST_PROTO_DEFAULT_EVAL(~, 1, expr));
|
||||
}
|
||||
|
||||
result_type invoke(Expr &expr, Context &context, mpl::true_, mpl::false_) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
typedef typename detail::classtypeof<function_type>::type class_type;
|
||||
return (
|
||||
BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, expr)) ->*
|
||||
BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)
|
||||
)();
|
||||
}
|
||||
|
||||
result_type invoke(Expr &expr, Context &context, mpl::false_, mpl::true_) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
typedef typename detail::classtypeof<function_type>::type class_type;
|
||||
return (
|
||||
BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, expr)) ->*
|
||||
BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
// Additional specialization are generated by the preprocessor
|
||||
#include <boost/proto/context/detail/default_eval.hpp>
|
||||
|
||||
#undef BOOST_PROTO_DEFAULT_EVAL_TYPE
|
||||
#undef BOOST_PROTO_DEFAULT_EVAL
|
||||
|
||||
/// default_context
|
||||
///
|
||||
struct default_context
|
||||
{
|
||||
/// default_context::eval
|
||||
///
|
||||
template<typename Expr, typename ThisContext = default_context const>
|
||||
struct eval
|
||||
: default_eval<Expr, ThisContext>
|
||||
{};
|
||||
};
|
||||
|
||||
} // namespace context
|
||||
|
||||
}} // namespace boost::proto
|
||||
|
||||
#undef UNREF
|
||||
|
||||
#endif
|
||||
113
test/external/boost/proto/context/detail/callable_eval.hpp
vendored
Normal file
113
test/external/boost/proto/context/detail/callable_eval.hpp
vendored
Normal file
@@ -0,0 +1,113 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/context/detail/preprocessed/callable_eval.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#define BOOST_PROTO_CHILD_N_TYPE(Z, N, Expr) \
|
||||
typedef typename proto::result_of::child_c<Expr const &, N>::type BOOST_PP_CAT(child, N); \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_CHILD_N(Z, N, expr) \
|
||||
proto::child_c<N>(expr) \
|
||||
/**/
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/callable_eval.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file callable_eval.hpp
|
||||
/// Contains specializations of the callable_eval\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/context/detail/callable_eval.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#undef BOOST_PROTO_CHILD_N_TYPE
|
||||
#undef BOOST_PROTO_CHILD_N
|
||||
|
||||
#else
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template<typename Expr, typename Context>
|
||||
struct is_expr_handled<Expr, Context, N>
|
||||
{
|
||||
static callable_context_wrapper<Context> &sctx_;
|
||||
static Expr &sexpr_;
|
||||
static typename Expr::proto_tag &stag_;
|
||||
|
||||
static const bool value =
|
||||
sizeof(yes_type) ==
|
||||
sizeof(
|
||||
detail::check_is_expr_handled(
|
||||
(sctx_(
|
||||
stag_
|
||||
BOOST_PP_ENUM_TRAILING(N, BOOST_PROTO_CHILD_N, sexpr_)
|
||||
), 0)
|
||||
)
|
||||
);
|
||||
|
||||
typedef mpl::bool_<value> type;
|
||||
};
|
||||
}
|
||||
|
||||
namespace context
|
||||
{
|
||||
/// \brief A BinaryFunction that accepts a Proto expression and a
|
||||
/// callable context and calls the context with the expression tag
|
||||
/// and children as arguments, effectively fanning the expression
|
||||
/// out.
|
||||
///
|
||||
/// <tt>callable_eval\<\></tt> requires that \c Context is a
|
||||
/// PolymorphicFunctionObject that can be invoked with \c Expr's
|
||||
/// tag and children as expressions, as follows:
|
||||
///
|
||||
/// \code
|
||||
/// context(Expr::proto_tag(), child_c\<0\>(expr), child_c\<1\>(expr), ...)
|
||||
/// \endcode
|
||||
template<typename Expr, typename Context>
|
||||
struct callable_eval<Expr, Context, N>
|
||||
{
|
||||
BOOST_PP_REPEAT(N, BOOST_PROTO_CHILD_N_TYPE, Expr)
|
||||
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
Context(
|
||||
typename Expr::proto_tag
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, child)
|
||||
)
|
||||
>::type
|
||||
result_type;
|
||||
|
||||
/// \param expr The current expression
|
||||
/// \param context The callable evaluation context
|
||||
/// \return <tt>context(Expr::proto_tag(), child_c\<0\>(expr), child_c\<1\>(expr), ...)</tt>
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return context(
|
||||
typename Expr::proto_tag()
|
||||
BOOST_PP_ENUM_TRAILING(N, BOOST_PROTO_CHILD_N, expr)
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#undef N
|
||||
|
||||
#endif
|
||||
82
test/external/boost/proto/context/detail/default_eval.hpp
vendored
Normal file
82
test/external/boost/proto/context/detail/default_eval.hpp
vendored
Normal file
@@ -0,0 +1,82 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/context/detail/preprocessed/default_eval.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#define BOOST_PROTO_DEFAULT_EVAL_SHIFTED(Z, M, DATA) \
|
||||
BOOST_PROTO_DEFAULT_EVAL(Z, BOOST_PP_ADD(M, 2), DATA) \
|
||||
/**/
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/default_eval.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file default_eval.hpp
|
||||
/// Contains specializations of the default_eval\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (3, BOOST_PROTO_MAX_ARITY, <boost/proto/context/detail/default_eval.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#undef BOOST_PROTO_DEFAULT_EVAL_SHIFTED
|
||||
|
||||
#else
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct default_eval<Expr, Context, proto::tag::function, N>
|
||||
{
|
||||
typedef
|
||||
typename proto::detail::result_of_fixup<
|
||||
BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr)
|
||||
>::type
|
||||
function_type;
|
||||
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
function_type(BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFAULT_EVAL_TYPE, Expr))
|
||||
>::type
|
||||
result_type;
|
||||
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return this->invoke(expr, context, is_member_function_pointer<function_type>());
|
||||
}
|
||||
|
||||
private:
|
||||
result_type invoke(Expr &expr, Context &context, mpl::false_) const
|
||||
{
|
||||
return BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)(
|
||||
BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFAULT_EVAL, expr)
|
||||
);
|
||||
}
|
||||
|
||||
result_type invoke(Expr &expr, Context &context, mpl::true_) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
typedef typename detail::classtypeof<function_type>::type class_type;
|
||||
return (
|
||||
BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, expr)) ->*
|
||||
BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)
|
||||
)(BOOST_PP_ENUM(BOOST_PP_SUB(N, 2), BOOST_PROTO_DEFAULT_EVAL_SHIFTED, expr));
|
||||
}
|
||||
};
|
||||
|
||||
#undef N
|
||||
|
||||
#endif
|
||||
54
test/external/boost/proto/context/detail/null_eval.hpp
vendored
Normal file
54
test/external/boost/proto/context/detail/null_eval.hpp
vendored
Normal file
@@ -0,0 +1,54 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/context/detail/preprocessed/null_eval.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#define BOOST_PROTO_EVAL_N(Z, N, DATA) \
|
||||
proto::eval(proto::child_c<N>(expr), ctx); \
|
||||
/**/
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/null_eval.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file null_eval.hpp
|
||||
/// Contains specializations of the null_eval\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/context/detail/null_eval.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#undef BOOST_PROTO_EVAL_N
|
||||
|
||||
#else
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct null_eval<Expr, Context, N>
|
||||
{
|
||||
typedef void result_type;
|
||||
|
||||
void operator ()(Expr &expr, Context &ctx) const
|
||||
{
|
||||
BOOST_PP_REPEAT(N, BOOST_PROTO_EVAL_N, ~)
|
||||
}
|
||||
};
|
||||
|
||||
#undef N
|
||||
|
||||
#endif
|
||||
597
test/external/boost/proto/context/detail/preprocessed/callable_eval.hpp
vendored
Normal file
597
test/external/boost/proto/context/detail/preprocessed/callable_eval.hpp
vendored
Normal file
@@ -0,0 +1,597 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file callable_eval.hpp
|
||||
/// Contains specializations of the callable_eval\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
namespace detail
|
||||
{
|
||||
template<typename Expr, typename Context>
|
||||
struct is_expr_handled<Expr, Context, 1>
|
||||
{
|
||||
static callable_context_wrapper<Context> &sctx_;
|
||||
static Expr &sexpr_;
|
||||
static typename Expr::proto_tag &stag_;
|
||||
static const bool value =
|
||||
sizeof(yes_type) ==
|
||||
sizeof(
|
||||
detail::check_is_expr_handled(
|
||||
(sctx_(
|
||||
stag_
|
||||
, proto::child_c< 0>( sexpr_)
|
||||
), 0)
|
||||
)
|
||||
);
|
||||
typedef mpl::bool_<value> type;
|
||||
};
|
||||
}
|
||||
namespace context
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct callable_eval<Expr, Context, 1>
|
||||
{
|
||||
typedef typename proto::result_of::child_c< Expr const &, 0>::type child0;
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
Context(
|
||||
typename Expr::proto_tag
|
||||
, child0
|
||||
)
|
||||
>::type
|
||||
result_type;
|
||||
|
||||
|
||||
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return context(
|
||||
typename Expr::proto_tag()
|
||||
, proto::child_c< 0>( expr)
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
namespace detail
|
||||
{
|
||||
template<typename Expr, typename Context>
|
||||
struct is_expr_handled<Expr, Context, 2>
|
||||
{
|
||||
static callable_context_wrapper<Context> &sctx_;
|
||||
static Expr &sexpr_;
|
||||
static typename Expr::proto_tag &stag_;
|
||||
static const bool value =
|
||||
sizeof(yes_type) ==
|
||||
sizeof(
|
||||
detail::check_is_expr_handled(
|
||||
(sctx_(
|
||||
stag_
|
||||
, proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_)
|
||||
), 0)
|
||||
)
|
||||
);
|
||||
typedef mpl::bool_<value> type;
|
||||
};
|
||||
}
|
||||
namespace context
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct callable_eval<Expr, Context, 2>
|
||||
{
|
||||
typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1;
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
Context(
|
||||
typename Expr::proto_tag
|
||||
, child0 , child1
|
||||
)
|
||||
>::type
|
||||
result_type;
|
||||
|
||||
|
||||
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return context(
|
||||
typename Expr::proto_tag()
|
||||
, proto::child_c< 0>( expr) , proto::child_c< 1>( expr)
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
namespace detail
|
||||
{
|
||||
template<typename Expr, typename Context>
|
||||
struct is_expr_handled<Expr, Context, 3>
|
||||
{
|
||||
static callable_context_wrapper<Context> &sctx_;
|
||||
static Expr &sexpr_;
|
||||
static typename Expr::proto_tag &stag_;
|
||||
static const bool value =
|
||||
sizeof(yes_type) ==
|
||||
sizeof(
|
||||
detail::check_is_expr_handled(
|
||||
(sctx_(
|
||||
stag_
|
||||
, proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_)
|
||||
), 0)
|
||||
)
|
||||
);
|
||||
typedef mpl::bool_<value> type;
|
||||
};
|
||||
}
|
||||
namespace context
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct callable_eval<Expr, Context, 3>
|
||||
{
|
||||
typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2;
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
Context(
|
||||
typename Expr::proto_tag
|
||||
, child0 , child1 , child2
|
||||
)
|
||||
>::type
|
||||
result_type;
|
||||
|
||||
|
||||
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return context(
|
||||
typename Expr::proto_tag()
|
||||
, proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr)
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
namespace detail
|
||||
{
|
||||
template<typename Expr, typename Context>
|
||||
struct is_expr_handled<Expr, Context, 4>
|
||||
{
|
||||
static callable_context_wrapper<Context> &sctx_;
|
||||
static Expr &sexpr_;
|
||||
static typename Expr::proto_tag &stag_;
|
||||
static const bool value =
|
||||
sizeof(yes_type) ==
|
||||
sizeof(
|
||||
detail::check_is_expr_handled(
|
||||
(sctx_(
|
||||
stag_
|
||||
, proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_)
|
||||
), 0)
|
||||
)
|
||||
);
|
||||
typedef mpl::bool_<value> type;
|
||||
};
|
||||
}
|
||||
namespace context
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct callable_eval<Expr, Context, 4>
|
||||
{
|
||||
typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3;
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
Context(
|
||||
typename Expr::proto_tag
|
||||
, child0 , child1 , child2 , child3
|
||||
)
|
||||
>::type
|
||||
result_type;
|
||||
|
||||
|
||||
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return context(
|
||||
typename Expr::proto_tag()
|
||||
, proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr)
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
namespace detail
|
||||
{
|
||||
template<typename Expr, typename Context>
|
||||
struct is_expr_handled<Expr, Context, 5>
|
||||
{
|
||||
static callable_context_wrapper<Context> &sctx_;
|
||||
static Expr &sexpr_;
|
||||
static typename Expr::proto_tag &stag_;
|
||||
static const bool value =
|
||||
sizeof(yes_type) ==
|
||||
sizeof(
|
||||
detail::check_is_expr_handled(
|
||||
(sctx_(
|
||||
stag_
|
||||
, proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_)
|
||||
), 0)
|
||||
)
|
||||
);
|
||||
typedef mpl::bool_<value> type;
|
||||
};
|
||||
}
|
||||
namespace context
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct callable_eval<Expr, Context, 5>
|
||||
{
|
||||
typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4;
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
Context(
|
||||
typename Expr::proto_tag
|
||||
, child0 , child1 , child2 , child3 , child4
|
||||
)
|
||||
>::type
|
||||
result_type;
|
||||
|
||||
|
||||
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return context(
|
||||
typename Expr::proto_tag()
|
||||
, proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr)
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
namespace detail
|
||||
{
|
||||
template<typename Expr, typename Context>
|
||||
struct is_expr_handled<Expr, Context, 6>
|
||||
{
|
||||
static callable_context_wrapper<Context> &sctx_;
|
||||
static Expr &sexpr_;
|
||||
static typename Expr::proto_tag &stag_;
|
||||
static const bool value =
|
||||
sizeof(yes_type) ==
|
||||
sizeof(
|
||||
detail::check_is_expr_handled(
|
||||
(sctx_(
|
||||
stag_
|
||||
, proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_)
|
||||
), 0)
|
||||
)
|
||||
);
|
||||
typedef mpl::bool_<value> type;
|
||||
};
|
||||
}
|
||||
namespace context
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct callable_eval<Expr, Context, 6>
|
||||
{
|
||||
typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5;
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
Context(
|
||||
typename Expr::proto_tag
|
||||
, child0 , child1 , child2 , child3 , child4 , child5
|
||||
)
|
||||
>::type
|
||||
result_type;
|
||||
|
||||
|
||||
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return context(
|
||||
typename Expr::proto_tag()
|
||||
, proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr)
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
namespace detail
|
||||
{
|
||||
template<typename Expr, typename Context>
|
||||
struct is_expr_handled<Expr, Context, 7>
|
||||
{
|
||||
static callable_context_wrapper<Context> &sctx_;
|
||||
static Expr &sexpr_;
|
||||
static typename Expr::proto_tag &stag_;
|
||||
static const bool value =
|
||||
sizeof(yes_type) ==
|
||||
sizeof(
|
||||
detail::check_is_expr_handled(
|
||||
(sctx_(
|
||||
stag_
|
||||
, proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_)
|
||||
), 0)
|
||||
)
|
||||
);
|
||||
typedef mpl::bool_<value> type;
|
||||
};
|
||||
}
|
||||
namespace context
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct callable_eval<Expr, Context, 7>
|
||||
{
|
||||
typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6;
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
Context(
|
||||
typename Expr::proto_tag
|
||||
, child0 , child1 , child2 , child3 , child4 , child5 , child6
|
||||
)
|
||||
>::type
|
||||
result_type;
|
||||
|
||||
|
||||
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return context(
|
||||
typename Expr::proto_tag()
|
||||
, proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr)
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
namespace detail
|
||||
{
|
||||
template<typename Expr, typename Context>
|
||||
struct is_expr_handled<Expr, Context, 8>
|
||||
{
|
||||
static callable_context_wrapper<Context> &sctx_;
|
||||
static Expr &sexpr_;
|
||||
static typename Expr::proto_tag &stag_;
|
||||
static const bool value =
|
||||
sizeof(yes_type) ==
|
||||
sizeof(
|
||||
detail::check_is_expr_handled(
|
||||
(sctx_(
|
||||
stag_
|
||||
, proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_) , proto::child_c< 7>( sexpr_)
|
||||
), 0)
|
||||
)
|
||||
);
|
||||
typedef mpl::bool_<value> type;
|
||||
};
|
||||
}
|
||||
namespace context
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct callable_eval<Expr, Context, 8>
|
||||
{
|
||||
typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6; typedef typename proto::result_of::child_c< Expr const &, 7>::type child7;
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
Context(
|
||||
typename Expr::proto_tag
|
||||
, child0 , child1 , child2 , child3 , child4 , child5 , child6 , child7
|
||||
)
|
||||
>::type
|
||||
result_type;
|
||||
|
||||
|
||||
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return context(
|
||||
typename Expr::proto_tag()
|
||||
, proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr) , proto::child_c< 7>( expr)
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
namespace detail
|
||||
{
|
||||
template<typename Expr, typename Context>
|
||||
struct is_expr_handled<Expr, Context, 9>
|
||||
{
|
||||
static callable_context_wrapper<Context> &sctx_;
|
||||
static Expr &sexpr_;
|
||||
static typename Expr::proto_tag &stag_;
|
||||
static const bool value =
|
||||
sizeof(yes_type) ==
|
||||
sizeof(
|
||||
detail::check_is_expr_handled(
|
||||
(sctx_(
|
||||
stag_
|
||||
, proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_) , proto::child_c< 7>( sexpr_) , proto::child_c< 8>( sexpr_)
|
||||
), 0)
|
||||
)
|
||||
);
|
||||
typedef mpl::bool_<value> type;
|
||||
};
|
||||
}
|
||||
namespace context
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct callable_eval<Expr, Context, 9>
|
||||
{
|
||||
typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6; typedef typename proto::result_of::child_c< Expr const &, 7>::type child7; typedef typename proto::result_of::child_c< Expr const &, 8>::type child8;
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
Context(
|
||||
typename Expr::proto_tag
|
||||
, child0 , child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8
|
||||
)
|
||||
>::type
|
||||
result_type;
|
||||
|
||||
|
||||
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return context(
|
||||
typename Expr::proto_tag()
|
||||
, proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr) , proto::child_c< 7>( expr) , proto::child_c< 8>( expr)
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
namespace detail
|
||||
{
|
||||
template<typename Expr, typename Context>
|
||||
struct is_expr_handled<Expr, Context, 10>
|
||||
{
|
||||
static callable_context_wrapper<Context> &sctx_;
|
||||
static Expr &sexpr_;
|
||||
static typename Expr::proto_tag &stag_;
|
||||
static const bool value =
|
||||
sizeof(yes_type) ==
|
||||
sizeof(
|
||||
detail::check_is_expr_handled(
|
||||
(sctx_(
|
||||
stag_
|
||||
, proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_) , proto::child_c< 7>( sexpr_) , proto::child_c< 8>( sexpr_) , proto::child_c< 9>( sexpr_)
|
||||
), 0)
|
||||
)
|
||||
);
|
||||
typedef mpl::bool_<value> type;
|
||||
};
|
||||
}
|
||||
namespace context
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct callable_eval<Expr, Context, 10>
|
||||
{
|
||||
typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6; typedef typename proto::result_of::child_c< Expr const &, 7>::type child7; typedef typename proto::result_of::child_c< Expr const &, 8>::type child8; typedef typename proto::result_of::child_c< Expr const &, 9>::type child9;
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
Context(
|
||||
typename Expr::proto_tag
|
||||
, child0 , child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 , child9
|
||||
)
|
||||
>::type
|
||||
result_type;
|
||||
|
||||
|
||||
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return context(
|
||||
typename Expr::proto_tag()
|
||||
, proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr) , proto::child_c< 7>( expr) , proto::child_c< 8>( expr) , proto::child_c< 9>( expr)
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
279
test/external/boost/proto/context/detail/preprocessed/default_eval.hpp
vendored
Normal file
279
test/external/boost/proto/context/detail/preprocessed/default_eval.hpp
vendored
Normal file
@@ -0,0 +1,279 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file default_eval.hpp
|
||||
/// Contains specializations of the default_eval\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
template<typename Expr, typename Context>
|
||||
struct default_eval<Expr, Context, proto::tag::function, 3>
|
||||
{
|
||||
typedef
|
||||
typename proto::detail::result_of_fixup<
|
||||
typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
|
||||
>::type
|
||||
function_type;
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type)
|
||||
>::type
|
||||
result_type;
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return this->invoke(expr, context, is_member_function_pointer<function_type>());
|
||||
}
|
||||
private:
|
||||
result_type invoke(Expr &expr, Context &context, mpl::false_) const
|
||||
{
|
||||
return proto::eval(proto::child_c< 0>( expr), context)(
|
||||
proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context)
|
||||
);
|
||||
}
|
||||
result_type invoke(Expr &expr, Context &context, mpl::true_) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
typedef typename detail::classtypeof<function_type>::type class_type;
|
||||
return (
|
||||
BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, expr)) ->*
|
||||
proto::eval(proto::child_c< 0>( expr), context)
|
||||
)(proto::eval(proto::child_c< 2>( expr), context));
|
||||
}
|
||||
};
|
||||
template<typename Expr, typename Context>
|
||||
struct default_eval<Expr, Context, proto::tag::function, 4>
|
||||
{
|
||||
typedef
|
||||
typename proto::detail::result_of_fixup<
|
||||
typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
|
||||
>::type
|
||||
function_type;
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type)
|
||||
>::type
|
||||
result_type;
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return this->invoke(expr, context, is_member_function_pointer<function_type>());
|
||||
}
|
||||
private:
|
||||
result_type invoke(Expr &expr, Context &context, mpl::false_) const
|
||||
{
|
||||
return proto::eval(proto::child_c< 0>( expr), context)(
|
||||
proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context)
|
||||
);
|
||||
}
|
||||
result_type invoke(Expr &expr, Context &context, mpl::true_) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
typedef typename detail::classtypeof<function_type>::type class_type;
|
||||
return (
|
||||
BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, expr)) ->*
|
||||
proto::eval(proto::child_c< 0>( expr), context)
|
||||
)(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context));
|
||||
}
|
||||
};
|
||||
template<typename Expr, typename Context>
|
||||
struct default_eval<Expr, Context, proto::tag::function, 5>
|
||||
{
|
||||
typedef
|
||||
typename proto::detail::result_of_fixup<
|
||||
typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
|
||||
>::type
|
||||
function_type;
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type)
|
||||
>::type
|
||||
result_type;
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return this->invoke(expr, context, is_member_function_pointer<function_type>());
|
||||
}
|
||||
private:
|
||||
result_type invoke(Expr &expr, Context &context, mpl::false_) const
|
||||
{
|
||||
return proto::eval(proto::child_c< 0>( expr), context)(
|
||||
proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context)
|
||||
);
|
||||
}
|
||||
result_type invoke(Expr &expr, Context &context, mpl::true_) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
typedef typename detail::classtypeof<function_type>::type class_type;
|
||||
return (
|
||||
BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, expr)) ->*
|
||||
proto::eval(proto::child_c< 0>( expr), context)
|
||||
)(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context));
|
||||
}
|
||||
};
|
||||
template<typename Expr, typename Context>
|
||||
struct default_eval<Expr, Context, proto::tag::function, 6>
|
||||
{
|
||||
typedef
|
||||
typename proto::detail::result_of_fixup<
|
||||
typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
|
||||
>::type
|
||||
function_type;
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type)
|
||||
>::type
|
||||
result_type;
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return this->invoke(expr, context, is_member_function_pointer<function_type>());
|
||||
}
|
||||
private:
|
||||
result_type invoke(Expr &expr, Context &context, mpl::false_) const
|
||||
{
|
||||
return proto::eval(proto::child_c< 0>( expr), context)(
|
||||
proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context)
|
||||
);
|
||||
}
|
||||
result_type invoke(Expr &expr, Context &context, mpl::true_) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
typedef typename detail::classtypeof<function_type>::type class_type;
|
||||
return (
|
||||
BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, expr)) ->*
|
||||
proto::eval(proto::child_c< 0>( expr), context)
|
||||
)(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context));
|
||||
}
|
||||
};
|
||||
template<typename Expr, typename Context>
|
||||
struct default_eval<Expr, Context, proto::tag::function, 7>
|
||||
{
|
||||
typedef
|
||||
typename proto::detail::result_of_fixup<
|
||||
typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
|
||||
>::type
|
||||
function_type;
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type)
|
||||
>::type
|
||||
result_type;
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return this->invoke(expr, context, is_member_function_pointer<function_type>());
|
||||
}
|
||||
private:
|
||||
result_type invoke(Expr &expr, Context &context, mpl::false_) const
|
||||
{
|
||||
return proto::eval(proto::child_c< 0>( expr), context)(
|
||||
proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context)
|
||||
);
|
||||
}
|
||||
result_type invoke(Expr &expr, Context &context, mpl::true_) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
typedef typename detail::classtypeof<function_type>::type class_type;
|
||||
return (
|
||||
BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, expr)) ->*
|
||||
proto::eval(proto::child_c< 0>( expr), context)
|
||||
)(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context));
|
||||
}
|
||||
};
|
||||
template<typename Expr, typename Context>
|
||||
struct default_eval<Expr, Context, proto::tag::function, 8>
|
||||
{
|
||||
typedef
|
||||
typename proto::detail::result_of_fixup<
|
||||
typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
|
||||
>::type
|
||||
function_type;
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 7>::type >::type , Context >::type)
|
||||
>::type
|
||||
result_type;
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return this->invoke(expr, context, is_member_function_pointer<function_type>());
|
||||
}
|
||||
private:
|
||||
result_type invoke(Expr &expr, Context &context, mpl::false_) const
|
||||
{
|
||||
return proto::eval(proto::child_c< 0>( expr), context)(
|
||||
proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context)
|
||||
);
|
||||
}
|
||||
result_type invoke(Expr &expr, Context &context, mpl::true_) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
typedef typename detail::classtypeof<function_type>::type class_type;
|
||||
return (
|
||||
BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, expr)) ->*
|
||||
proto::eval(proto::child_c< 0>( expr), context)
|
||||
)(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context));
|
||||
}
|
||||
};
|
||||
template<typename Expr, typename Context>
|
||||
struct default_eval<Expr, Context, proto::tag::function, 9>
|
||||
{
|
||||
typedef
|
||||
typename proto::detail::result_of_fixup<
|
||||
typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
|
||||
>::type
|
||||
function_type;
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 7>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 8>::type >::type , Context >::type)
|
||||
>::type
|
||||
result_type;
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return this->invoke(expr, context, is_member_function_pointer<function_type>());
|
||||
}
|
||||
private:
|
||||
result_type invoke(Expr &expr, Context &context, mpl::false_) const
|
||||
{
|
||||
return proto::eval(proto::child_c< 0>( expr), context)(
|
||||
proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context)
|
||||
);
|
||||
}
|
||||
result_type invoke(Expr &expr, Context &context, mpl::true_) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
typedef typename detail::classtypeof<function_type>::type class_type;
|
||||
return (
|
||||
BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, expr)) ->*
|
||||
proto::eval(proto::child_c< 0>( expr), context)
|
||||
)(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context));
|
||||
}
|
||||
};
|
||||
template<typename Expr, typename Context>
|
||||
struct default_eval<Expr, Context, proto::tag::function, 10>
|
||||
{
|
||||
typedef
|
||||
typename proto::detail::result_of_fixup<
|
||||
typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
|
||||
>::type
|
||||
function_type;
|
||||
typedef
|
||||
typename BOOST_PROTO_RESULT_OF<
|
||||
function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 7>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 8>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 9>::type >::type , Context >::type)
|
||||
>::type
|
||||
result_type;
|
||||
result_type operator ()(Expr &expr, Context &context) const
|
||||
{
|
||||
return this->invoke(expr, context, is_member_function_pointer<function_type>());
|
||||
}
|
||||
private:
|
||||
result_type invoke(Expr &expr, Context &context, mpl::false_) const
|
||||
{
|
||||
return proto::eval(proto::child_c< 0>( expr), context)(
|
||||
proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context) , proto::eval(proto::child_c< 9>( expr), context)
|
||||
);
|
||||
}
|
||||
result_type invoke(Expr &expr, Context &context, mpl::true_) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
typedef typename detail::classtypeof<function_type>::type class_type;
|
||||
return (
|
||||
BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, expr)) ->*
|
||||
proto::eval(proto::child_c< 0>( expr), context)
|
||||
)(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context) , proto::eval(proto::child_c< 9>( expr), context));
|
||||
}
|
||||
};
|
||||
97
test/external/boost/proto/context/detail/preprocessed/null_eval.hpp
vendored
Normal file
97
test/external/boost/proto/context/detail/preprocessed/null_eval.hpp
vendored
Normal file
@@ -0,0 +1,97 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file null_eval.hpp
|
||||
/// Contains specializations of the null_eval\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
template<typename Expr, typename Context>
|
||||
struct null_eval<Expr, Context, 1>
|
||||
{
|
||||
typedef void result_type;
|
||||
void operator ()(Expr &expr, Context &ctx) const
|
||||
{
|
||||
proto::eval(proto::child_c< 0>(expr), ctx);
|
||||
}
|
||||
};
|
||||
template<typename Expr, typename Context>
|
||||
struct null_eval<Expr, Context, 2>
|
||||
{
|
||||
typedef void result_type;
|
||||
void operator ()(Expr &expr, Context &ctx) const
|
||||
{
|
||||
proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx);
|
||||
}
|
||||
};
|
||||
template<typename Expr, typename Context>
|
||||
struct null_eval<Expr, Context, 3>
|
||||
{
|
||||
typedef void result_type;
|
||||
void operator ()(Expr &expr, Context &ctx) const
|
||||
{
|
||||
proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx);
|
||||
}
|
||||
};
|
||||
template<typename Expr, typename Context>
|
||||
struct null_eval<Expr, Context, 4>
|
||||
{
|
||||
typedef void result_type;
|
||||
void operator ()(Expr &expr, Context &ctx) const
|
||||
{
|
||||
proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx);
|
||||
}
|
||||
};
|
||||
template<typename Expr, typename Context>
|
||||
struct null_eval<Expr, Context, 5>
|
||||
{
|
||||
typedef void result_type;
|
||||
void operator ()(Expr &expr, Context &ctx) const
|
||||
{
|
||||
proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx);
|
||||
}
|
||||
};
|
||||
template<typename Expr, typename Context>
|
||||
struct null_eval<Expr, Context, 6>
|
||||
{
|
||||
typedef void result_type;
|
||||
void operator ()(Expr &expr, Context &ctx) const
|
||||
{
|
||||
proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx);
|
||||
}
|
||||
};
|
||||
template<typename Expr, typename Context>
|
||||
struct null_eval<Expr, Context, 7>
|
||||
{
|
||||
typedef void result_type;
|
||||
void operator ()(Expr &expr, Context &ctx) const
|
||||
{
|
||||
proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx);
|
||||
}
|
||||
};
|
||||
template<typename Expr, typename Context>
|
||||
struct null_eval<Expr, Context, 8>
|
||||
{
|
||||
typedef void result_type;
|
||||
void operator ()(Expr &expr, Context &ctx) const
|
||||
{
|
||||
proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx); proto::eval(proto::child_c< 7>(expr), ctx);
|
||||
}
|
||||
};
|
||||
template<typename Expr, typename Context>
|
||||
struct null_eval<Expr, Context, 9>
|
||||
{
|
||||
typedef void result_type;
|
||||
void operator ()(Expr &expr, Context &ctx) const
|
||||
{
|
||||
proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx); proto::eval(proto::child_c< 7>(expr), ctx); proto::eval(proto::child_c< 8>(expr), ctx);
|
||||
}
|
||||
};
|
||||
template<typename Expr, typename Context>
|
||||
struct null_eval<Expr, Context, 10>
|
||||
{
|
||||
typedef void result_type;
|
||||
void operator ()(Expr &expr, Context &ctx) const
|
||||
{
|
||||
proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx); proto::eval(proto::child_c< 7>(expr), ctx); proto::eval(proto::child_c< 8>(expr), ctx); proto::eval(proto::child_c< 9>(expr), ctx);
|
||||
}
|
||||
};
|
||||
56
test/external/boost/proto/context/null.hpp
vendored
Normal file
56
test/external/boost/proto/context/null.hpp
vendored
Normal file
@@ -0,0 +1,56 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file null.hpp
|
||||
/// Definintion of null_context\<\>, an evaluation context for
|
||||
/// proto::eval() that simply evaluates each child expression, doesn't
|
||||
/// combine the results at all, and returns void.
|
||||
//
|
||||
// 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_CONTEXT_NULL_HPP_EAN_06_24_2007
|
||||
#define BOOST_PROTO_CONTEXT_NULL_HPP_EAN_06_24_2007
|
||||
|
||||
#include <boost/preprocessor/iteration/iterate.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/eval.hpp>
|
||||
#include <boost/proto/traits.hpp>
|
||||
|
||||
namespace boost { namespace proto { namespace context
|
||||
{
|
||||
|
||||
template<
|
||||
typename Expr
|
||||
, typename Context
|
||||
, long Arity // = Expr::proto_arity_c
|
||||
>
|
||||
struct null_eval
|
||||
{};
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct null_eval<Expr, Context, 0>
|
||||
{
|
||||
typedef void result_type;
|
||||
void operator()(Expr &, Context &) const
|
||||
{}
|
||||
};
|
||||
|
||||
// Additional specializations generated by the preprocessor
|
||||
#include <boost/proto/context/detail/null_eval.hpp>
|
||||
|
||||
/// null_context
|
||||
///
|
||||
struct null_context
|
||||
{
|
||||
/// null_context::eval
|
||||
///
|
||||
template<typename Expr, typename ThisContext = null_context const>
|
||||
struct eval
|
||||
: null_eval<Expr, ThisContext>
|
||||
{};
|
||||
};
|
||||
|
||||
}}}
|
||||
|
||||
#endif
|
||||
30
test/external/boost/proto/core.hpp
vendored
Normal file
30
test/external/boost/proto/core.hpp
vendored
Normal file
@@ -0,0 +1,30 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file core.hpp
|
||||
/// Includes the core of Proto. Not included are the contexts, transforms and
|
||||
/// debugging utilities.
|
||||
//
|
||||
// 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_CORE_HPP_EAN_04_01_2005
|
||||
#define BOOST_PROTO_CORE_HPP_EAN_04_01_2005
|
||||
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/args.hpp>
|
||||
#include <boost/proto/tags.hpp>
|
||||
#include <boost/proto/eval.hpp>
|
||||
#include <boost/proto/expr.hpp>
|
||||
#include <boost/proto/repeat.hpp>
|
||||
#include <boost/proto/traits.hpp>
|
||||
#include <boost/proto/domain.hpp>
|
||||
#include <boost/proto/fusion.hpp>
|
||||
#include <boost/proto/matches.hpp>
|
||||
#include <boost/proto/extends.hpp>
|
||||
#include <boost/proto/literal.hpp>
|
||||
#include <boost/proto/generate.hpp>
|
||||
#include <boost/proto/operators.hpp>
|
||||
#include <boost/proto/deep_copy.hpp>
|
||||
#include <boost/proto/make_expr.hpp>
|
||||
|
||||
#endif
|
||||
264
test/external/boost/proto/debug.hpp
vendored
Normal file
264
test/external/boost/proto/debug.hpp
vendored
Normal file
@@ -0,0 +1,264 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file debug.hpp
|
||||
/// Utilities for debugging Proto expression trees
|
||||
//
|
||||
// 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_DEBUG_HPP_EAN_12_31_2006
|
||||
#define BOOST_PROTO_DEBUG_HPP_EAN_12_31_2006
|
||||
|
||||
#include <iostream>
|
||||
#include <boost/preprocessor/stringize.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
#include <boost/mpl/assert.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/traits.hpp>
|
||||
#include <boost/proto/matches.hpp>
|
||||
#include <boost/proto/fusion.hpp>
|
||||
#include <boost/fusion/algorithm/iteration/for_each.hpp>
|
||||
#include <boost/detail/sp_typeinfo.hpp>
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
namespace tagns_ { namespace tag
|
||||
{
|
||||
#define BOOST_PROTO_DEFINE_TAG_INSERTION(Tag) \
|
||||
/** \brief INTERNAL ONLY */ \
|
||||
inline std::ostream &operator <<(std::ostream &sout, Tag const &) \
|
||||
{ \
|
||||
return sout << BOOST_PP_STRINGIZE(Tag); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(terminal)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(unary_plus)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(negate)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(dereference)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(complement)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(address_of)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(logical_not)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(pre_inc)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(pre_dec)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(post_inc)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(post_dec)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(shift_left)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(shift_right)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(multiplies)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(divides)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(modulus)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(plus)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(minus)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(less)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(greater)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(less_equal)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(greater_equal)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(equal_to)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(not_equal_to)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(logical_or)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(logical_and)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_and)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_or)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_xor)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(comma)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(mem_ptr)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(assign)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(shift_left_assign)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(shift_right_assign)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(multiplies_assign)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(divides_assign)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(modulus_assign)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(plus_assign)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(minus_assign)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_and_assign)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_or_assign)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_xor_assign)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(subscript)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(member)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(if_else_)
|
||||
BOOST_PROTO_DEFINE_TAG_INSERTION(function)
|
||||
|
||||
#undef BOOST_PROTO_DEFINE_TAG_INSERTION
|
||||
}}
|
||||
|
||||
namespace hidden_detail_
|
||||
{
|
||||
struct ostream_wrapper
|
||||
{
|
||||
ostream_wrapper(std::ostream &sout)
|
||||
: sout_(sout)
|
||||
{}
|
||||
|
||||
std::ostream &sout_;
|
||||
};
|
||||
|
||||
struct named_any
|
||||
{
|
||||
template<typename T>
|
||||
named_any(T const &)
|
||||
: name_(BOOST_SP_TYPEID(T).name())
|
||||
{}
|
||||
|
||||
char const *name_;
|
||||
};
|
||||
|
||||
inline std::ostream &operator <<(ostream_wrapper sout_wrap, named_any t)
|
||||
{
|
||||
return sout_wrap.sout_ << t.name_;
|
||||
}
|
||||
}
|
||||
|
||||
namespace detail
|
||||
{
|
||||
struct display_expr_impl
|
||||
{
|
||||
explicit display_expr_impl(std::ostream &sout, int depth = 0)
|
||||
: depth_(depth)
|
||||
, first_(true)
|
||||
, sout_(sout)
|
||||
{}
|
||||
|
||||
template<typename Expr>
|
||||
void operator()(Expr const &expr) const
|
||||
{
|
||||
this->impl(expr, mpl::long_<arity_of<Expr>::value>());
|
||||
}
|
||||
|
||||
private:
|
||||
display_expr_impl(display_expr_impl const &);
|
||||
display_expr_impl &operator =(display_expr_impl const &);
|
||||
|
||||
template<typename Expr>
|
||||
void impl(Expr const &expr, mpl::long_<0>) const
|
||||
{
|
||||
using namespace hidden_detail_;
|
||||
typedef typename tag_of<Expr>::type tag;
|
||||
this->sout_.width(this->depth_);
|
||||
this->sout_ << (this->first_? "" : ", ");
|
||||
this->sout_ << tag() << "(" << proto::value(expr) << ")\n";
|
||||
this->first_ = false;
|
||||
}
|
||||
|
||||
template<typename Expr, typename Arity>
|
||||
void impl(Expr const &expr, Arity) const
|
||||
{
|
||||
using namespace hidden_detail_;
|
||||
typedef typename tag_of<Expr>::type tag;
|
||||
this->sout_.width(this->depth_);
|
||||
this->sout_ << (this->first_? "" : ", ");
|
||||
this->sout_ << tag() << "(\n";
|
||||
display_expr_impl display(this->sout_, this->depth_ + 4);
|
||||
fusion::for_each(expr, display);
|
||||
this->sout_.width(this->depth_);
|
||||
this->sout_ << "" << ")\n";
|
||||
this->first_ = false;
|
||||
}
|
||||
|
||||
int depth_;
|
||||
mutable bool first_;
|
||||
std::ostream &sout_;
|
||||
};
|
||||
}
|
||||
|
||||
namespace functional
|
||||
{
|
||||
/// \brief Pretty-print a Proto expression tree.
|
||||
///
|
||||
/// A PolymorphicFunctionObject which accepts a Proto expression
|
||||
/// tree and pretty-prints it to an \c ostream for debugging
|
||||
/// purposes.
|
||||
struct display_expr
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
|
||||
typedef void result_type;
|
||||
|
||||
/// \param sout The \c ostream to which the expression tree
|
||||
/// will be written.
|
||||
/// \param depth The starting indentation depth for this node.
|
||||
/// Children nodes will be displayed at a starting
|
||||
/// depth of <tt>depth+4</tt>.
|
||||
explicit display_expr(std::ostream &sout = std::cout, int depth = 0)
|
||||
: depth_(depth)
|
||||
, sout_(sout)
|
||||
{}
|
||||
|
||||
/// \brief Pretty-print the current node in a Proto expression
|
||||
/// tree.
|
||||
template<typename Expr>
|
||||
void operator()(Expr const &expr) const
|
||||
{
|
||||
detail::display_expr_impl(this->sout_, this->depth_)(expr);
|
||||
}
|
||||
|
||||
private:
|
||||
int depth_;
|
||||
reference_wrapper<std::ostream> sout_;
|
||||
};
|
||||
}
|
||||
|
||||
/// \brief Pretty-print a Proto expression tree.
|
||||
///
|
||||
/// \note Equivalent to <tt>functional::display_expr(0, sout)(expr)</tt>
|
||||
/// \param expr The Proto expression tree to pretty-print
|
||||
/// \param sout The \c ostream to which the output should be
|
||||
/// written. If not specified, defaults to
|
||||
/// <tt>std::cout</tt>.
|
||||
template<typename Expr>
|
||||
void display_expr(Expr const &expr, std::ostream &sout)
|
||||
{
|
||||
functional::display_expr(sout, 0)(expr);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
///
|
||||
template<typename Expr>
|
||||
void display_expr(Expr const &expr)
|
||||
{
|
||||
functional::display_expr()(expr);
|
||||
}
|
||||
|
||||
/// \brief Assert at compile time that a particular expression
|
||||
/// matches the specified grammar.
|
||||
///
|
||||
/// \note Equivalent to <tt>BOOST_MPL_ASSERT((proto::matches\<Expr, Grammar\>))</tt>
|
||||
/// \param expr The Proto expression to check againts <tt>Grammar</tt>
|
||||
template<typename Grammar, typename Expr>
|
||||
void assert_matches(Expr const & /*expr*/)
|
||||
{
|
||||
BOOST_MPL_ASSERT((proto::matches<Expr, Grammar>));
|
||||
}
|
||||
|
||||
/// \brief Assert at compile time that a particular expression
|
||||
/// does not match the specified grammar.
|
||||
///
|
||||
/// \note Equivalent to <tt>BOOST_MPL_ASSERT_NOT((proto::matches\<Expr, Grammar\>))</tt>
|
||||
/// \param expr The Proto expression to check againts <tt>Grammar</tt>
|
||||
template<typename Grammar, typename Expr>
|
||||
void assert_matches_not(Expr const & /*expr*/)
|
||||
{
|
||||
BOOST_MPL_ASSERT_NOT((proto::matches<Expr, Grammar>));
|
||||
}
|
||||
|
||||
/// \brief Assert at compile time that a particular expression
|
||||
/// matches the specified grammar.
|
||||
///
|
||||
/// \note Equivalent to <tt>proto::assert_matches\<Grammar\>(Expr)</tt>
|
||||
/// \param Expr The Proto expression to check againts <tt>Grammar</tt>
|
||||
/// \param Grammar The grammar used to validate Expr.
|
||||
#define BOOST_PROTO_ASSERT_MATCHES(Expr, Grammar) \
|
||||
(true ? (void)0 : boost::proto::assert_matches<Grammar>(Expr))
|
||||
|
||||
/// \brief Assert at compile time that a particular expression
|
||||
/// does not match the specified grammar.
|
||||
///
|
||||
/// \note Equivalent to <tt>proto::assert_matches_not\<Grammar\>(Expr)</tt>
|
||||
/// \param Expr The Proto expression to check againts <tt>Grammar</tt>
|
||||
/// \param Grammar The grammar used to validate Expr.
|
||||
#define BOOST_PROTO_ASSERT_MATCHES_NOT(Expr, Grammar) \
|
||||
(true ? (void)0 : boost::proto::assert_matches_not<Grammar>(Expr))
|
||||
|
||||
}}
|
||||
|
||||
#endif
|
||||
163
test/external/boost/proto/deep_copy.hpp
vendored
Normal file
163
test/external/boost/proto/deep_copy.hpp
vendored
Normal file
@@ -0,0 +1,163 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file deep_copy.hpp
|
||||
/// Replace all nodes stored by reference by nodes stored by value.
|
||||
//
|
||||
// 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_DEEP_COPY_HPP_EAN_11_21_2006
|
||||
#define BOOST_PROTO_DEEP_COPY_HPP_EAN_11_21_2006
|
||||
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/repetition/enum.hpp>
|
||||
#include <boost/preprocessor/iteration/iterate.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/type_traits/remove_reference.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/args.hpp>
|
||||
#include <boost/proto/expr.hpp>
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
template<typename Expr, long Arity = Expr::proto_arity_c>
|
||||
struct deep_copy_impl;
|
||||
|
||||
template<typename Expr>
|
||||
struct deep_copy_impl<Expr, 0>
|
||||
{
|
||||
typedef
|
||||
typename base_expr<
|
||||
typename Expr::proto_domain
|
||||
, tag::terminal
|
||||
, term<typename term_traits<typename Expr::proto_child0>::value_type>
|
||||
>::type
|
||||
expr_type;
|
||||
|
||||
typedef typename Expr::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
|
||||
template<typename Expr2, typename S, typename D>
|
||||
result_type operator()(Expr2 const &e, S const &, D const &) const
|
||||
{
|
||||
return proto_generator()(expr_type::make(e.proto_base().child0));
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
/// \brief A metafunction for calculating the return type
|
||||
/// of \c proto::deep_copy().
|
||||
///
|
||||
/// A metafunction for calculating the return type
|
||||
/// of \c proto::deep_copy(). The type parameter \c Expr
|
||||
/// should be the type of a Proto expression tree.
|
||||
/// It should not be a reference type, nor should it
|
||||
/// be cv-qualified.
|
||||
template<typename Expr>
|
||||
struct deep_copy
|
||||
{
|
||||
typedef
|
||||
typename detail::deep_copy_impl<
|
||||
BOOST_PROTO_UNCVREF(Expr)
|
||||
>::result_type
|
||||
type;
|
||||
};
|
||||
}
|
||||
|
||||
namespace functional
|
||||
{
|
||||
/// \brief A PolymorphicFunctionObject type for deep-copying
|
||||
/// Proto expression trees.
|
||||
///
|
||||
/// A PolymorphicFunctionObject type for deep-copying
|
||||
/// Proto expression trees. When a tree is deep-copied,
|
||||
/// all internal nodes and most terminals held by reference
|
||||
/// are instead held by value.
|
||||
///
|
||||
/// \attention Terminals of reference-to-function type are
|
||||
/// left unchanged. Terminals of reference-to-array type are
|
||||
/// stored by value, which can cause a large amount of data
|
||||
/// to be passed by value and stored on the stack.
|
||||
struct deep_copy
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr)>
|
||||
{
|
||||
typedef
|
||||
typename detail::deep_copy_impl<
|
||||
BOOST_PROTO_UNCVREF(Expr)
|
||||
>::result_type
|
||||
type;
|
||||
};
|
||||
|
||||
/// \brief Deep-copies a Proto expression tree, turning all
|
||||
/// nodes and terminals held by reference into ones held by
|
||||
/// value.
|
||||
template<typename Expr>
|
||||
typename result_of::deep_copy<Expr>::type
|
||||
operator()(Expr const &e) const
|
||||
{
|
||||
return proto::detail::deep_copy_impl<Expr>()(e, 0, 0);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/// \brief A function for deep-copying
|
||||
/// Proto expression trees.
|
||||
///
|
||||
/// A function for deep-copying
|
||||
/// Proto expression trees. When a tree is deep-copied,
|
||||
/// all internal nodes and most terminals held by reference
|
||||
/// are instead held by value.
|
||||
///
|
||||
/// \attention Terminals of reference-to-function type are
|
||||
/// left unchanged.
|
||||
///
|
||||
/// \sa proto::functional::deep_copy.
|
||||
template<typename Expr>
|
||||
typename proto::result_of::deep_copy<Expr>::type
|
||||
deep_copy(Expr const &e)
|
||||
{
|
||||
return proto::detail::deep_copy_impl<Expr>()(e, 0, 0);
|
||||
}
|
||||
|
||||
/// \brief A PrimitiveTransform for deep-copying
|
||||
/// Proto expression trees.
|
||||
///
|
||||
/// A PrimitiveTransform for deep-copying
|
||||
/// Proto expression trees. When a tree is deep-copied,
|
||||
/// all internal nodes and most terminals held by reference
|
||||
/// are instead held by value.
|
||||
///
|
||||
/// \attention Terminals of reference-to-function type are
|
||||
/// left unchanged.
|
||||
///
|
||||
/// \sa proto::functional::deep_copy.
|
||||
struct _deep_copy
|
||||
: proto::transform<_deep_copy>
|
||||
{
|
||||
template<typename E, typename S, typename D>
|
||||
struct impl
|
||||
: detail::deep_copy_impl<BOOST_PROTO_UNCVREF(E)>
|
||||
{};
|
||||
};
|
||||
|
||||
namespace detail
|
||||
{
|
||||
// include the definition of deep_copy_impl
|
||||
#include <boost/proto/detail/deep_copy.hpp>
|
||||
}
|
||||
|
||||
}}
|
||||
|
||||
#endif // BOOST_PROTO_COMPILER_DEEP_COPY_HPP_EAN_11_21_2006
|
||||
|
||||
94
test/external/boost/proto/detail/and_n.hpp
vendored
Normal file
94
test/external/boost/proto/detail/and_n.hpp
vendored
Normal file
@@ -0,0 +1,94 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/and_n.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/and_n.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file and_n.hpp
|
||||
/// Definitions of and_N, and_impl
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (2, BOOST_PP_MAX(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_MAX_LOGICAL_ARITY), <boost/proto/detail/and_n.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#else // BOOST_PP_IS_ITERATING
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
// Assymetry here between the handling of and_N and or_N because
|
||||
// and_N is used by lambda_matches up to BOOST_PROTO_MAX_ARITY,
|
||||
// regardless of how low BOOST_PROTO_MAX_LOGICAL_ARITY is.
|
||||
template<bool B, BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), typename P)>
|
||||
struct BOOST_PP_CAT(and_, N)
|
||||
#if 2 == N
|
||||
: mpl::bool_<P0::value>
|
||||
{};
|
||||
#else
|
||||
: BOOST_PP_CAT(and_, BOOST_PP_DEC(N))<
|
||||
P0::value BOOST_PP_COMMA_IF(BOOST_PP_SUB(N,2))
|
||||
BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_DEC(N), P)
|
||||
>
|
||||
{};
|
||||
#endif
|
||||
|
||||
template<BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), typename P)>
|
||||
struct BOOST_PP_CAT(and_, N)<false, BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), P)>
|
||||
: mpl::false_
|
||||
{};
|
||||
|
||||
#if N <= BOOST_PROTO_MAX_LOGICAL_ARITY
|
||||
|
||||
template<BOOST_PP_ENUM_PARAMS(N, typename G), typename Expr, typename State, typename Data>
|
||||
struct _and_impl<proto::and_<BOOST_PP_ENUM_PARAMS(N, G)>, Expr, State, Data>
|
||||
: proto::transform_impl<Expr, State, Data>
|
||||
{
|
||||
#define M0(Z, N, DATA) \
|
||||
typedef \
|
||||
typename proto::when<proto::_, BOOST_PP_CAT(G, N)> \
|
||||
::template impl<Expr, State, Data> \
|
||||
BOOST_PP_CAT(Gimpl, N); \
|
||||
/**/
|
||||
BOOST_PP_REPEAT(N, M0, ~)
|
||||
#undef M0
|
||||
|
||||
typedef typename BOOST_PP_CAT(Gimpl, BOOST_PP_DEC(N))::result_type result_type;
|
||||
|
||||
result_type operator()(
|
||||
typename _and_impl::expr_param e
|
||||
, typename _and_impl::state_param s
|
||||
, typename _and_impl::data_param d
|
||||
) const
|
||||
{
|
||||
// Fix: jfalcou - 12/29/2010
|
||||
// Avoid the use of comma operator here so as not to find Proto's
|
||||
// by accident.
|
||||
// expands to G0()(e,s,d); G1()(e,s,d); ... G{N-1}()(e,s,d);
|
||||
#define M0(Z,N,DATA) BOOST_PP_CAT(Gimpl,N)()(e,s,d);
|
||||
BOOST_PP_REPEAT(BOOST_PP_DEC(N),M0,~)
|
||||
return BOOST_PP_CAT(Gimpl,BOOST_PP_DEC(N))()(e,s,d);
|
||||
#undef M0
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#undef N
|
||||
|
||||
#endif
|
||||
85
test/external/boost/proto/detail/args.hpp
vendored
Normal file
85
test/external/boost/proto/detail/args.hpp
vendored
Normal file
@@ -0,0 +1,85 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/args.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_DEFINE_CHILD_N(Z, N, DATA) \
|
||||
typedef BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(child, N); \
|
||||
/**< INTERNAL ONLY */
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_DEFINE_VOID_N(z, n, data) \
|
||||
typedef mpl::void_ BOOST_PP_CAT(child, n); \
|
||||
/**< INTERNAL ONLY */
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/args.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file args.hpp
|
||||
/// Contains definition of \c term\<\>, \c list1\<\>, \c list2\<\>, ...
|
||||
/// class templates.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
/// \brief A type sequence, for use as the 2nd parameter to the \c expr\<\> class template.
|
||||
///
|
||||
/// A type sequence, for use as the 2nd parameter to the \c expr\<\> class template.
|
||||
/// The types in the sequence correspond to the children of a node in an expression tree.
|
||||
template< typename Arg0 >
|
||||
struct term
|
||||
{
|
||||
static const long arity = 0;
|
||||
typedef Arg0 child0;
|
||||
BOOST_PP_REPEAT_FROM_TO(1, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_DEFINE_VOID_N, ~)
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef Arg0 back_;
|
||||
};
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/args.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#undef BOOST_PROTO_DEFINE_VOID_N
|
||||
#undef BOOST_PROTO_DEFINE_CHILD_N
|
||||
|
||||
#else
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
/// \brief A type sequence, for use as the 2nd parameter to the \c expr\<\> class template.
|
||||
///
|
||||
/// A type sequence, for use as the 2nd parameter to the \c expr\<\> class template.
|
||||
/// The types in the sequence correspond to the children of a node in an expression tree.
|
||||
template< BOOST_PP_ENUM_PARAMS(N, typename Arg) >
|
||||
struct BOOST_PP_CAT(list, N)
|
||||
{
|
||||
static const long arity = N;
|
||||
BOOST_PP_REPEAT(N, BOOST_PROTO_DEFINE_CHILD_N, ~)
|
||||
BOOST_PP_REPEAT_FROM_TO(N, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_DEFINE_VOID_N, ~)
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef BOOST_PP_CAT(Arg, BOOST_PP_DEC(N)) back_;
|
||||
};
|
||||
|
||||
#undef N
|
||||
|
||||
#endif
|
||||
170
test/external/boost/proto/detail/as_expr.hpp
vendored
Normal file
170
test/external/boost/proto/detail/as_expr.hpp
vendored
Normal file
@@ -0,0 +1,170 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file as_expr.hpp
|
||||
/// Contains definition of the as_expr\<\> and as_child\<\> helper class
|
||||
/// templates used to implement proto::domain's as_expr\<\> and as_child\<\>
|
||||
/// member templates.
|
||||
//
|
||||
// Copyright 2010 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_DETAIL_AS_EXPR_HPP_EAN_06_09_2010
|
||||
#define BOOST_PROTO_DETAIL_AS_EXPR_HPP_EAN_06_09_2010
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/type_traits/remove_const.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/args.hpp>
|
||||
|
||||
namespace boost { namespace proto { namespace detail
|
||||
{
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename Generator>
|
||||
struct base_generator
|
||||
{
|
||||
typedef Generator type;
|
||||
};
|
||||
|
||||
template<typename Generator>
|
||||
struct base_generator<use_basic_expr<Generator> >
|
||||
{
|
||||
typedef Generator type;
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T, typename Generator, bool WantsBasicExpr>
|
||||
struct as_expr;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T, typename Generator>
|
||||
struct as_expr<T, Generator, false>
|
||||
{
|
||||
typedef typename term_traits<T &>::value_type value_type;
|
||||
typedef proto::expr<proto::tag::terminal, term<value_type>, 0> expr_type;
|
||||
typedef typename Generator::template result<Generator(expr_type)>::type result_type;
|
||||
|
||||
result_type operator()(T &t) const
|
||||
{
|
||||
return Generator()(expr_type::make(t));
|
||||
}
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T, typename Generator>
|
||||
struct as_expr<T, Generator, true>
|
||||
{
|
||||
typedef typename term_traits<T &>::value_type value_type;
|
||||
typedef proto::basic_expr<proto::tag::terminal, term<value_type>, 0> expr_type;
|
||||
typedef typename Generator::template result<Generator(expr_type)>::type result_type;
|
||||
|
||||
result_type operator()(T &t) const
|
||||
{
|
||||
return Generator()(expr_type::make(t));
|
||||
}
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T>
|
||||
struct as_expr<T, proto::default_generator, false>
|
||||
{
|
||||
typedef typename term_traits<T &>::value_type value_type;
|
||||
typedef proto::expr<proto::tag::terminal, term<value_type>, 0> result_type;
|
||||
|
||||
result_type operator()(T &t) const
|
||||
{
|
||||
return result_type::make(t);
|
||||
}
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T>
|
||||
struct as_expr<T, proto::default_generator, true>
|
||||
{
|
||||
typedef typename term_traits<T &>::value_type value_type;
|
||||
typedef proto::basic_expr<proto::tag::terminal, term<value_type>, 0> result_type;
|
||||
|
||||
result_type operator()(T &t) const
|
||||
{
|
||||
return result_type::make(t);
|
||||
}
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T, typename Generator, bool WantsBasicExpr>
|
||||
struct as_child;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T, typename Generator>
|
||||
struct as_child<T, Generator, false>
|
||||
{
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
|
||||
typedef typename term_traits<T &>::reference reference;
|
||||
#else
|
||||
typedef T &reference;
|
||||
#endif
|
||||
typedef proto::expr<proto::tag::terminal, term<reference>, 0> expr_type;
|
||||
typedef typename Generator::template result<Generator(expr_type)>::type result_type;
|
||||
|
||||
result_type operator()(T &t) const
|
||||
{
|
||||
return Generator()(expr_type::make(t));
|
||||
}
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T, typename Generator>
|
||||
struct as_child<T, Generator, true>
|
||||
{
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
|
||||
typedef typename term_traits<T &>::reference reference;
|
||||
#else
|
||||
typedef T &reference;
|
||||
#endif
|
||||
typedef proto::basic_expr<proto::tag::terminal, term<reference>, 0> expr_type;
|
||||
typedef typename Generator::template result<Generator(expr_type)>::type result_type;
|
||||
|
||||
result_type operator()(T &t) const
|
||||
{
|
||||
return Generator()(expr_type::make(t));
|
||||
}
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T>
|
||||
struct as_child<T, proto::default_generator, false>
|
||||
{
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
|
||||
typedef typename term_traits<T &>::reference reference;
|
||||
#else
|
||||
typedef T &reference;
|
||||
#endif
|
||||
typedef proto::expr<proto::tag::terminal, term<reference>, 0> result_type;
|
||||
|
||||
result_type operator()(T &t) const
|
||||
{
|
||||
return result_type::make(t);
|
||||
}
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T>
|
||||
struct as_child<T, proto::default_generator, true>
|
||||
{
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
|
||||
typedef typename term_traits<T &>::reference reference;
|
||||
#else
|
||||
typedef T &reference;
|
||||
#endif
|
||||
typedef proto::basic_expr<proto::tag::terminal, term<reference>, 0> result_type;
|
||||
|
||||
result_type operator()(T &t) const
|
||||
{
|
||||
return result_type::make(t);
|
||||
}
|
||||
};
|
||||
|
||||
}}}
|
||||
|
||||
#endif
|
||||
32
test/external/boost/proto/detail/as_lvalue.hpp
vendored
Normal file
32
test/external/boost/proto/detail/as_lvalue.hpp
vendored
Normal file
@@ -0,0 +1,32 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file as_lvalue.hpp
|
||||
/// Contains definition the as_lvalue() functions.
|
||||
//
|
||||
// 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_TRANSFORM_AS_LVALUE_HPP_EAN_12_27_2007
|
||||
#define BOOST_PROTO_TRANSFORM_AS_LVALUE_HPP_EAN_12_27_2007
|
||||
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
template<typename T>
|
||||
T &as_lvalue(T &t)
|
||||
{
|
||||
return t;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T const &as_lvalue(T const &t)
|
||||
{
|
||||
return t;
|
||||
}
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
179
test/external/boost/proto/detail/basic_expr.hpp
vendored
Normal file
179
test/external/boost/proto/detail/basic_expr.hpp
vendored
Normal file
@@ -0,0 +1,179 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/basic_expr.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_CHILD(Z, N, DATA) \
|
||||
typedef BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(proto_child, N); \
|
||||
BOOST_PP_CAT(proto_child, N) BOOST_PP_CAT(child, N); \
|
||||
/**< INTERNAL ONLY */
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_VOID(Z, N, DATA) \
|
||||
typedef void BOOST_PP_CAT(proto_child, N); \
|
||||
/**< INTERNAL ONLY */
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/basic_expr.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file basic_expr.hpp
|
||||
/// Contains definition of basic_expr\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
// The expr<> specializations are actually defined here.
|
||||
#define BOOST_PROTO_DEFINE_TERMINAL
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 (3, (0, 0, <boost/proto/detail/basic_expr.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#undef BOOST_PROTO_DEFINE_TERMINAL
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/basic_expr.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#undef BOOST_PROTO_CHILD
|
||||
#undef BOOST_PROTO_VOID
|
||||
|
||||
#else
|
||||
|
||||
#define ARG_COUNT BOOST_PP_MAX(1, BOOST_PP_ITERATION())
|
||||
|
||||
/// \brief Simplified representation of a node in an expression tree.
|
||||
///
|
||||
/// \c proto::basic_expr\<\> is a node in an expression template tree. It
|
||||
/// is a container for its child sub-trees. It also serves as
|
||||
/// the terminal nodes of the tree.
|
||||
///
|
||||
/// \c Tag is type that represents the operation encoded by
|
||||
/// this expression. It is typically one of the structs
|
||||
/// in the \c boost::proto::tag namespace, but it doesn't
|
||||
/// have to be.
|
||||
///
|
||||
/// \c Args is a type list representing the type of the children
|
||||
/// of this expression. It is an instantiation of one
|
||||
/// of \c proto::list1\<\>, \c proto::list2\<\>, etc. The
|
||||
/// child types must all themselves be either \c expr\<\>
|
||||
/// or <tt>proto::expr\<\>&</tt>. If \c Args is an
|
||||
/// instantiation of \c proto::term\<\> then this
|
||||
/// \c expr\<\> type represents a terminal expression;
|
||||
/// the parameter to the \c proto::term\<\> template
|
||||
/// represents the terminal's value type.
|
||||
///
|
||||
/// \c Arity is an integral constant representing the number of child
|
||||
/// nodes this node contains. If \c Arity is 0, then this
|
||||
/// node is a terminal.
|
||||
///
|
||||
/// \c proto::basic_expr\<\> is a valid Fusion random-access sequence, where
|
||||
/// the elements of the sequence are the child expressions.
|
||||
#ifdef BOOST_PROTO_DEFINE_TERMINAL
|
||||
template<typename Tag, typename Arg0>
|
||||
struct basic_expr<Tag, term<Arg0>, 0>
|
||||
#else
|
||||
template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(ARG_COUNT, typename Arg)>
|
||||
struct basic_expr<Tag, BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)>, BOOST_PP_ITERATION() >
|
||||
#endif
|
||||
{
|
||||
typedef Tag proto_tag;
|
||||
static const long proto_arity_c = BOOST_PP_ITERATION();
|
||||
typedef mpl::long_<BOOST_PP_ITERATION() > proto_arity;
|
||||
typedef basic_expr proto_base_expr;
|
||||
#ifdef BOOST_PROTO_DEFINE_TERMINAL
|
||||
typedef term<Arg0> proto_args;
|
||||
#else
|
||||
typedef BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)> proto_args;
|
||||
#endif
|
||||
typedef basic_expr proto_grammar;
|
||||
typedef basic_default_domain proto_domain;
|
||||
typedef default_generator proto_generator;
|
||||
typedef proto::tag::proto_expr fusion_tag;
|
||||
typedef basic_expr proto_derived_expr;
|
||||
typedef void proto_is_expr_; /**< INTERNAL ONLY */
|
||||
|
||||
BOOST_PP_REPEAT(ARG_COUNT, BOOST_PROTO_CHILD, ~)
|
||||
BOOST_PP_REPEAT_FROM_TO(ARG_COUNT, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_VOID, ~)
|
||||
|
||||
/// \return *this
|
||||
///
|
||||
basic_expr const &proto_base() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
///
|
||||
basic_expr &proto_base()
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
#ifdef BOOST_PROTO_DEFINE_TERMINAL
|
||||
/// \return A new \c expr\<\> object initialized with the specified
|
||||
/// arguments.
|
||||
///
|
||||
template<typename A0>
|
||||
static basic_expr const make(A0 &a0)
|
||||
{
|
||||
return detail::make_terminal(a0, static_cast<basic_expr *>(0), static_cast<proto_args *>(0));
|
||||
}
|
||||
|
||||
/// \overload
|
||||
///
|
||||
template<typename A0>
|
||||
static basic_expr const make(A0 const &a0)
|
||||
{
|
||||
return detail::make_terminal(a0, static_cast<basic_expr *>(0), static_cast<proto_args *>(0));
|
||||
}
|
||||
#else
|
||||
/// \return A new \c expr\<\> object initialized with the specified
|
||||
/// arguments.
|
||||
///
|
||||
template<BOOST_PP_ENUM_PARAMS(ARG_COUNT, typename A)>
|
||||
static basic_expr const make(BOOST_PP_ENUM_BINARY_PARAMS(ARG_COUNT, A, const &a))
|
||||
{
|
||||
basic_expr that = {BOOST_PP_ENUM_PARAMS(ARG_COUNT, a)};
|
||||
return that;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if 1 == BOOST_PP_ITERATION()
|
||||
/// If \c Tag is \c boost::proto::tag::address_of and \c proto_child0 is
|
||||
/// <tt>T&</tt>, then \c address_of_hack_type_ is <tt>T*</tt>.
|
||||
/// Otherwise, it is some undefined type.
|
||||
typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_;
|
||||
|
||||
/// \return The address of <tt>this->child0</tt> if \c Tag is
|
||||
/// \c boost::proto::tag::address_of. Otherwise, this function will
|
||||
/// fail to compile.
|
||||
///
|
||||
/// \attention Proto overloads <tt>operator&</tt>, which means that
|
||||
/// proto-ified objects cannot have their addresses taken, unless we use
|
||||
/// the following hack to make \c &x implicitly convertible to \c X*.
|
||||
operator address_of_hack_type_() const
|
||||
{
|
||||
return boost::addressof(this->child0);
|
||||
}
|
||||
#else
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef detail::not_a_valid_type address_of_hack_type_;
|
||||
#endif
|
||||
};
|
||||
|
||||
#undef ARG_COUNT
|
||||
|
||||
#endif
|
||||
49
test/external/boost/proto/detail/classtypeof.hpp
vendored
Normal file
49
test/external/boost/proto/detail/classtypeof.hpp
vendored
Normal file
@@ -0,0 +1,49 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/classtypeof.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/classtypeof.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// classtypeof.hpp
|
||||
// Contains specializations of the classtypeof\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/classtypeof.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
template<typename T, typename U BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
|
||||
struct classtypeof<T (U::*)(BOOST_PP_ENUM_PARAMS(N, A))>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
|
||||
template<typename T, typename U BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
|
||||
struct classtypeof<T (U::*)(BOOST_PP_ENUM_PARAMS(N, A)) const>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
|
||||
#undef N
|
||||
|
||||
#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES
|
||||
501
test/external/boost/proto/detail/decltype.hpp
vendored
Normal file
501
test/external/boost/proto/detail/decltype.hpp
vendored
Normal file
@@ -0,0 +1,501 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file decltype.hpp
|
||||
/// Contains definition the BOOST_PROTO_DECLTYPE_() macro and assorted helpers
|
||||
//
|
||||
// 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_DETAIL_DECLTYPE_HPP_EAN_04_04_2008
|
||||
#define BOOST_PROTO_DETAIL_DECLTYPE_HPP_EAN_04_04_2008
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/get_pointer.hpp>
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
|
||||
#include <boost/preprocessor/iteration/local.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/mpl/eval_if.hpp>
|
||||
#include <boost/mpl/identity.hpp>
|
||||
#include <boost/type_traits/is_class.hpp>
|
||||
#include <boost/type_traits/remove_reference.hpp>
|
||||
#include <boost/type_traits/is_pointer.hpp>
|
||||
#include <boost/type_traits/is_function.hpp>
|
||||
#include <boost/type_traits/is_member_object_pointer.hpp>
|
||||
#include <boost/type_traits/add_const.hpp>
|
||||
#include <boost/type_traits/add_reference.hpp>
|
||||
#include <boost/typeof/typeof.hpp>
|
||||
#include <boost/utility/addressof.hpp>
|
||||
#include <boost/utility/result_of.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
|
||||
#ifndef BOOST_NO_DECLTYPE
|
||||
# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) typedef decltype(EXPR) TYPE;
|
||||
#else
|
||||
# define BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(NESTED, EXPR) \
|
||||
BOOST_TYPEOF_NESTED_TYPEDEF_TPL(BOOST_PP_CAT(nested_and_hidden_, NESTED), EXPR) \
|
||||
static int const BOOST_PP_CAT(sz, NESTED) = sizeof(boost::proto::detail::check_reference(EXPR));\
|
||||
struct NESTED \
|
||||
: boost::mpl::if_c< \
|
||||
1 == BOOST_PP_CAT(sz, NESTED) \
|
||||
, typename BOOST_PP_CAT(nested_and_hidden_, NESTED)::type & \
|
||||
, typename BOOST_PP_CAT(nested_and_hidden_, NESTED)::type \
|
||||
> \
|
||||
{};
|
||||
# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) \
|
||||
BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(BOOST_PP_CAT(nested_, TYPE), (EXPR)) \
|
||||
typedef typename BOOST_PP_CAT(nested_, TYPE)::type TYPE;
|
||||
#endif
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
namespace anyns
|
||||
{
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
struct any
|
||||
{
|
||||
any(...);
|
||||
any operator=(any);
|
||||
any operator[](any);
|
||||
#define M0(Z, N, DATA) any operator()(BOOST_PP_ENUM_PARAMS_Z(Z, N, any BOOST_PP_INTERCEPT));
|
||||
BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, M0, ~)
|
||||
#undef M0
|
||||
|
||||
template<typename T>
|
||||
operator T &() const volatile;
|
||||
|
||||
any operator+();
|
||||
any operator-();
|
||||
any operator*();
|
||||
any operator&();
|
||||
any operator~();
|
||||
any operator!();
|
||||
any operator++();
|
||||
any operator--();
|
||||
any operator++(int);
|
||||
any operator--(int);
|
||||
|
||||
friend any operator<<(any, any);
|
||||
friend any operator>>(any, any);
|
||||
friend any operator*(any, any);
|
||||
friend any operator/(any, any);
|
||||
friend any operator%(any, any);
|
||||
friend any operator+(any, any);
|
||||
friend any operator-(any, any);
|
||||
friend any operator<(any, any);
|
||||
friend any operator>(any, any);
|
||||
friend any operator<=(any, any);
|
||||
friend any operator>=(any, any);
|
||||
friend any operator==(any, any);
|
||||
friend any operator!=(any, any);
|
||||
friend any operator||(any, any);
|
||||
friend any operator&&(any, any);
|
||||
friend any operator&(any, any);
|
||||
friend any operator|(any, any);
|
||||
friend any operator^(any, any);
|
||||
friend any operator,(any, any);
|
||||
friend any operator->*(any, any);
|
||||
|
||||
friend any operator<<=(any, any);
|
||||
friend any operator>>=(any, any);
|
||||
friend any operator*=(any, any);
|
||||
friend any operator/=(any, any);
|
||||
friend any operator%=(any, any);
|
||||
friend any operator+=(any, any);
|
||||
friend any operator-=(any, any);
|
||||
friend any operator&=(any, any);
|
||||
friend any operator|=(any, any);
|
||||
friend any operator^=(any, any);
|
||||
};
|
||||
}
|
||||
|
||||
using anyns::any;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T>
|
||||
struct as_mutable
|
||||
{
|
||||
typedef T &type;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct as_mutable<T &>
|
||||
{
|
||||
typedef T &type;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct as_mutable<T const &>
|
||||
{
|
||||
typedef T &type;
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T>
|
||||
T make();
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T>
|
||||
typename as_mutable<T>::type make_mutable();
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T>
|
||||
struct subscript_wrapper
|
||||
: T
|
||||
{
|
||||
using T::operator[];
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
|
||||
any operator[](any const volatile &) const volatile;
|
||||
#else
|
||||
any operator[](any const &) const volatile;
|
||||
#endif
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T>
|
||||
struct as_subscriptable
|
||||
{
|
||||
typedef
|
||||
typename mpl::if_c<
|
||||
is_class<T>::value
|
||||
, subscript_wrapper<T>
|
||||
, T
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct as_subscriptable<T const>
|
||||
{
|
||||
typedef
|
||||
typename mpl::if_c<
|
||||
is_class<T>::value
|
||||
, subscript_wrapper<T> const
|
||||
, T const
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct as_subscriptable<T &>
|
||||
{
|
||||
typedef
|
||||
typename mpl::if_c<
|
||||
is_class<T>::value
|
||||
, subscript_wrapper<T> &
|
||||
, T &
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct as_subscriptable<T const &>
|
||||
{
|
||||
typedef
|
||||
typename mpl::if_c<
|
||||
is_class<T>::value
|
||||
, subscript_wrapper<T> const &
|
||||
, T const &
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T>
|
||||
typename as_subscriptable<T>::type make_subscriptable();
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T>
|
||||
char check_reference(T &);
|
||||
|
||||
template<typename T>
|
||||
char (&check_reference(T const &))[2];
|
||||
|
||||
namespace has_get_pointerns
|
||||
{
|
||||
using boost::get_pointer;
|
||||
void *(&get_pointer(...))[2];
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T>
|
||||
struct has_get_pointer
|
||||
{
|
||||
static const bool value = sizeof(void *) == sizeof(get_pointer(make<T &>()));
|
||||
typedef mpl::bool_<value> type;
|
||||
};
|
||||
}
|
||||
|
||||
using has_get_pointerns::has_get_pointer;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T>
|
||||
struct classtypeof;
|
||||
|
||||
template<typename T, typename U>
|
||||
struct classtypeof<T U::*>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
|
||||
// Other specializations are generated by the preprocessor
|
||||
#include <boost/proto/detail/classtypeof.hpp>
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T>
|
||||
T &lvalue(T &t)
|
||||
{
|
||||
return t;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T const &lvalue(T const &t)
|
||||
{
|
||||
return t;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename U, typename V, typename T>
|
||||
U *proto_get_pointer(T &t, V *, U *)
|
||||
{
|
||||
return boost::addressof(t);
|
||||
}
|
||||
|
||||
template<typename U, typename V, typename T>
|
||||
U const *proto_get_pointer(T &t, V *, U const *)
|
||||
{
|
||||
return boost::addressof(t);
|
||||
}
|
||||
|
||||
template<typename U, typename V, typename T>
|
||||
V *proto_get_pointer(T &t, V *, ...)
|
||||
{
|
||||
return get_pointer(t);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
#define BOOST_PROTO_USE_GET_POINTER() \
|
||||
using namespace boost::proto::detail::get_pointerns \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_GET_POINTER(Type, Obj) \
|
||||
boost::proto::detail::proto_get_pointer<Type>( \
|
||||
boost::proto::detail::lvalue(Obj) \
|
||||
, (true ? 0 : get_pointer(Obj)) \
|
||||
, (true ? 0 : boost::addressof(boost::proto::detail::lvalue(Obj))) \
|
||||
) \
|
||||
/**/
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
namespace get_pointerns
|
||||
{
|
||||
using boost::get_pointer;
|
||||
|
||||
template<typename T>
|
||||
typename disable_if_c<has_get_pointer<T>::value, T *>::type
|
||||
get_pointer(T &t)
|
||||
{
|
||||
return boost::addressof(t);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
typename disable_if_c<has_get_pointer<T>::value, T const *>::type
|
||||
get_pointer(T const &t)
|
||||
{
|
||||
return boost::addressof(t);
|
||||
}
|
||||
|
||||
char test_ptr_to_const(void *);
|
||||
char (&test_ptr_to_const(void const *))[2];
|
||||
|
||||
template<typename U> char test_V_is_a_U(U *);
|
||||
template<typename U> char test_V_is_a_U(U const *);
|
||||
template<typename U> char (&test_V_is_a_U(...))[2];
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// result_of_ is a wrapper around boost::result_of that also handles "invocations" of
|
||||
// member object pointers.
|
||||
template<typename T, typename Void = void>
|
||||
struct result_of_
|
||||
: BOOST_PROTO_RESULT_OF<T>
|
||||
{};
|
||||
|
||||
template<typename T, typename U, typename V>
|
||||
struct result_of_<T U::*(V), typename enable_if_c<is_member_object_pointer<T U::*>::value>::type>
|
||||
{
|
||||
static const bool is_V_a_smart_ptr = 2 == sizeof(test_V_is_a_U<U>(&lvalue(make<V>())));
|
||||
static const bool is_ptr_to_const = 2 == sizeof(test_ptr_to_const(BOOST_PROTO_GET_POINTER(U, make<V>())));
|
||||
|
||||
// If V is not a U, then it is a (smart) pointer and we can always return an lvalue.
|
||||
// Otherwise, we can only return an lvalue if we are given one.
|
||||
typedef
|
||||
typename mpl::eval_if_c<
|
||||
(is_V_a_smart_ptr || is_reference<V>::value)
|
||||
, mpl::eval_if_c<
|
||||
is_ptr_to_const
|
||||
, add_reference<typename add_const<T>::type>
|
||||
, add_reference<T>
|
||||
>
|
||||
, mpl::identity<T>
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<
|
||||
typename T
|
||||
, typename U
|
||||
, bool IsMemPtr = is_member_object_pointer<
|
||||
typename remove_reference<U>::type
|
||||
>::value
|
||||
>
|
||||
struct mem_ptr_fun
|
||||
{
|
||||
BOOST_PROTO_DECLTYPE_(
|
||||
proto::detail::make_mutable<T>() ->* proto::detail::make<U>()
|
||||
, result_type
|
||||
)
|
||||
|
||||
result_type operator()(
|
||||
typename add_reference<typename add_const<T>::type>::type t
|
||||
, typename add_reference<typename add_const<U>::type>::type u
|
||||
) const
|
||||
{
|
||||
return t ->* u;
|
||||
}
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T, typename U>
|
||||
struct mem_ptr_fun<T, U, true>
|
||||
{
|
||||
typedef
|
||||
typename classtypeof<
|
||||
typename uncvref<U>::type
|
||||
>::type
|
||||
V;
|
||||
|
||||
BOOST_PROTO_DECLTYPE_(
|
||||
BOOST_PROTO_GET_POINTER(V, proto::detail::make_mutable<T>()) ->* proto::detail::make<U>()
|
||||
, result_type
|
||||
)
|
||||
|
||||
result_type operator()(
|
||||
typename add_reference<typename add_const<T>::type>::type t
|
||||
, U u
|
||||
) const
|
||||
{
|
||||
return BOOST_PROTO_GET_POINTER(V, t) ->* u;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
using get_pointerns::result_of_;
|
||||
using get_pointerns::mem_ptr_fun;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename A0, typename A1>
|
||||
struct comma_result
|
||||
{
|
||||
BOOST_PROTO_DECLTYPE_((proto::detail::make<A0>(), proto::detail::make<A1>()), type)
|
||||
};
|
||||
|
||||
template<typename A0>
|
||||
struct comma_result<A0, void>
|
||||
{
|
||||
typedef void type;
|
||||
};
|
||||
|
||||
template<typename A1>
|
||||
struct comma_result<void, A1>
|
||||
{
|
||||
typedef A1 type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct comma_result<void, void>
|
||||
{
|
||||
typedef void type;
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// normalize a function type for use with boost::result_of
|
||||
template<typename T, typename U = T>
|
||||
struct result_of_fixup
|
||||
: mpl::if_c<is_function<T>::value, T *, U>
|
||||
{};
|
||||
|
||||
template<typename T, typename U>
|
||||
struct result_of_fixup<T &, U>
|
||||
: result_of_fixup<T, T>
|
||||
{};
|
||||
|
||||
template<typename T, typename U>
|
||||
struct result_of_fixup<T const &, U>
|
||||
: result_of_fixup<T, T>
|
||||
{};
|
||||
|
||||
template<typename T, typename U>
|
||||
struct result_of_fixup<T *, U>
|
||||
: result_of_fixup<T, U>
|
||||
{};
|
||||
|
||||
template<typename R, typename T, typename U>
|
||||
struct result_of_fixup<R T::*, U>
|
||||
{
|
||||
typedef R T::*type;
|
||||
};
|
||||
|
||||
template<typename T, typename U>
|
||||
struct result_of_fixup<T const, U>
|
||||
: result_of_fixup<T, U>
|
||||
{};
|
||||
|
||||
//// Tests for result_of_fixup
|
||||
//struct bar {};
|
||||
//BOOST_MPL_ASSERT((is_same<bar, result_of_fixup<bar>::type>));
|
||||
//BOOST_MPL_ASSERT((is_same<bar const, result_of_fixup<bar const>::type>));
|
||||
//BOOST_MPL_ASSERT((is_same<bar, result_of_fixup<bar &>::type>));
|
||||
//BOOST_MPL_ASSERT((is_same<bar const, result_of_fixup<bar const &>::type>));
|
||||
//BOOST_MPL_ASSERT((is_same<void(*)(), result_of_fixup<void(*)()>::type>));
|
||||
//BOOST_MPL_ASSERT((is_same<void(*)(), result_of_fixup<void(* const)()>::type>));
|
||||
//BOOST_MPL_ASSERT((is_same<void(*)(), result_of_fixup<void(* const &)()>::type>));
|
||||
//BOOST_MPL_ASSERT((is_same<void(*)(), result_of_fixup<void(&)()>::type>));
|
||||
|
||||
template<typename T, typename PMF>
|
||||
struct memfun
|
||||
{
|
||||
typedef typename uncvref<PMF>::type pmf_type;
|
||||
typedef typename classtypeof<pmf_type>::type V;
|
||||
typedef typename BOOST_PROTO_RESULT_OF<pmf_type(T)>::type result_type;
|
||||
|
||||
memfun(T t, PMF p)
|
||||
: obj(t)
|
||||
, pmf(p)
|
||||
{}
|
||||
|
||||
result_type operator()() const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)();
|
||||
}
|
||||
|
||||
// Other overloads generated by the preprocessor
|
||||
#include <boost/proto/detail/memfun_funop.hpp>
|
||||
|
||||
private:
|
||||
T obj;
|
||||
PMF pmf;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
}}
|
||||
|
||||
#endif
|
||||
199
test/external/boost/proto/detail/deduce_domain.hpp
vendored
Normal file
199
test/external/boost/proto/detail/deduce_domain.hpp
vendored
Normal file
@@ -0,0 +1,199 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file deduce_domain.hpp
|
||||
/// Contains definition of deduce_domain\<\> class templates
|
||||
/// for finding the domain that is common among the specified
|
||||
/// domains
|
||||
//
|
||||
// Copyright 2010 Daniel Wallin, 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)
|
||||
//
|
||||
// Many thanks to Daniel Wallin who first implemented this code. Thanks
|
||||
// also to Jeremiah Willcock, John Bytheway and Krishna Achuthan who
|
||||
// offered alternate solutions to this tricky programming problem.
|
||||
|
||||
#ifndef BOOST_PROTO_DEDUCE_DOMAIN_HPP_EAN_05_22_2010
|
||||
#define BOOST_PROTO_DEDUCE_DOMAIN_HPP_EAN_05_22_2010
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/facilities/intercept.hpp>
|
||||
#include <boost/preprocessor/iteration/local.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
|
||||
#include <boost/preprocessor/arithmetic/inc.hpp>
|
||||
#include <boost/mpl/assert.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
|
||||
#ifndef BOOST_PROTO_ASSERT_VALID_DOMAIN
|
||||
# define BOOST_PROTO_ASSERT_VALID_DOMAIN(DOM) BOOST_MPL_ASSERT_NOT((boost::is_same<DOM, boost::proto::detail::not_a_domain>))
|
||||
#endif
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace proto
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
template<typename Domain>
|
||||
struct domain_
|
||||
: domain_<typename Domain::proto_super_domain>
|
||||
{
|
||||
typedef Domain type;
|
||||
typedef domain_<typename Domain::proto_super_domain> base;
|
||||
#ifdef BOOST_NO_DECLTYPE
|
||||
using base::deduce98;
|
||||
static int const index = base::index + 1;
|
||||
static typename sized_type<index>::type deduce98(domain_<Domain>*);
|
||||
#else
|
||||
using base::deduce0x;
|
||||
static Domain deduce0x(domain_<Domain>*);
|
||||
#endif
|
||||
};
|
||||
|
||||
template<>
|
||||
struct domain_<not_a_domain>
|
||||
{
|
||||
typedef not_a_domain type;
|
||||
#ifdef BOOST_NO_DECLTYPE
|
||||
static int const index = 1;
|
||||
static sized_type<1>::type deduce98(void*);
|
||||
#else
|
||||
static not_a_domain deduce0x(void*);
|
||||
#endif
|
||||
};
|
||||
|
||||
template<>
|
||||
struct domain_<default_domain>
|
||||
: domain_<not_a_domain>
|
||||
{};
|
||||
|
||||
template<>
|
||||
struct domain_<basic_default_domain>
|
||||
: domain_<not_a_domain>
|
||||
{};
|
||||
|
||||
sized_type<1>::type default_test(void*, void*);
|
||||
sized_type<2>::type default_test(domain_<default_domain>*, void*);
|
||||
sized_type<2>::type default_test(domain_<basic_default_domain>*, void*);
|
||||
sized_type<3>::type default_test(void*, domain_<default_domain>*);
|
||||
sized_type<3>::type default_test(void*, domain_<basic_default_domain>*);
|
||||
sized_type<4>::type default_test(domain_<default_domain>*, domain_<default_domain>*);
|
||||
sized_type<4>::type default_test(domain_<basic_default_domain>*, domain_<default_domain>*);
|
||||
sized_type<4>::type default_test(domain_<default_domain>*, domain_<basic_default_domain>*);
|
||||
sized_type<4>::type default_test(domain_<basic_default_domain>*, domain_<basic_default_domain>*);
|
||||
|
||||
#ifdef BOOST_NO_DECLTYPE
|
||||
template<int N, typename Domain>
|
||||
struct nth_domain
|
||||
: nth_domain<N - 1, typename Domain::base>
|
||||
{};
|
||||
|
||||
template<typename Domain>
|
||||
struct nth_domain<0, Domain>
|
||||
: Domain
|
||||
{};
|
||||
#endif
|
||||
|
||||
template<typename D0>
|
||||
struct common_domain1
|
||||
{
|
||||
typedef D0 type;
|
||||
};
|
||||
|
||||
template<typename E0>
|
||||
struct deduce_domain1
|
||||
: domain_of<E0>
|
||||
{};
|
||||
|
||||
template<
|
||||
typename D0
|
||||
, typename D1
|
||||
, int DefaultCase = sizeof(proto::detail::default_test((domain_<D0>*)0, (domain_<D1>*)0))
|
||||
>
|
||||
struct common_domain2
|
||||
{
|
||||
#ifdef BOOST_NO_DECLTYPE
|
||||
static int const index = domain_<D0>::index - sizeof(domain_<D0>::deduce98((domain_<D1>*)0));
|
||||
typedef typename nth_domain<index, domain_<D0> >::type type;
|
||||
#else
|
||||
typedef decltype(domain_<D0>::deduce0x((domain_<D1>*)0)) type;
|
||||
#endif
|
||||
};
|
||||
|
||||
template<typename D0, typename D1>
|
||||
struct common_domain2<D0, D1, 2>
|
||||
{
|
||||
typedef D1 type;
|
||||
};
|
||||
|
||||
template<typename D0, typename D1>
|
||||
struct common_domain2<D0, D1, 3>
|
||||
{
|
||||
typedef D0 type;
|
||||
};
|
||||
|
||||
template<typename D0>
|
||||
struct common_domain2<D0, default_domain, 4>
|
||||
{
|
||||
typedef D0 type;
|
||||
};
|
||||
|
||||
template<typename D0>
|
||||
struct common_domain2<D0, basic_default_domain, 4>
|
||||
{
|
||||
typedef D0 type;
|
||||
};
|
||||
|
||||
template<typename D1>
|
||||
struct common_domain2<default_domain, D1, 4>
|
||||
{
|
||||
typedef D1 type;
|
||||
};
|
||||
|
||||
template<typename D1>
|
||||
struct common_domain2<basic_default_domain, D1, 4>
|
||||
{
|
||||
typedef D1 type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct common_domain2<default_domain, default_domain, 4>
|
||||
{
|
||||
typedef default_domain type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct common_domain2<basic_default_domain, default_domain, 4>
|
||||
{
|
||||
typedef default_domain type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct common_domain2<default_domain, basic_default_domain, 4>
|
||||
{
|
||||
typedef default_domain type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct common_domain2<basic_default_domain, basic_default_domain, 4>
|
||||
{
|
||||
typedef basic_default_domain type;
|
||||
};
|
||||
|
||||
template<typename E0, typename E1>
|
||||
struct deduce_domain2
|
||||
: common_domain2<
|
||||
typename domain_of<E0>::type
|
||||
, typename domain_of<E1>::type
|
||||
>
|
||||
{};
|
||||
|
||||
#include <boost/proto/detail/deduce_domain_n.hpp>
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif // BOOST_PROTO_DEDUCE_DOMAIN_HPP_EAN_05_22_2010
|
||||
64
test/external/boost/proto/detail/deduce_domain_n.hpp
vendored
Normal file
64
test/external/boost/proto/detail/deduce_domain_n.hpp
vendored
Normal file
@@ -0,0 +1,64 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/deduce_domain_n.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#define BOOST_PROTO_COMMON_DOMAIN2(Z, N, DATA) \
|
||||
typedef \
|
||||
typename common_domain2<common ## N, A ## N>::type \
|
||||
BOOST_PP_CAT(common, BOOST_PP_INC(N)); \
|
||||
/**/
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/deduce_domain_n.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// deduce_domain_n.hpp
|
||||
// Definitions of common_domain[n] and deduce_domain[n] class templates.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (3, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/deduce_domain_n.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#undef BOOST_PROTO_COMMON_DOMAIN2
|
||||
|
||||
#else
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
template<BOOST_PP_ENUM_PARAMS(N, typename A)>
|
||||
struct BOOST_PP_CAT(common_domain, N)
|
||||
{
|
||||
typedef A0 common1;
|
||||
BOOST_PP_REPEAT_FROM_TO(1, N, BOOST_PROTO_COMMON_DOMAIN2, ~)
|
||||
typedef BOOST_PP_CAT(common, N) type;
|
||||
BOOST_PROTO_ASSERT_VALID_DOMAIN(type);
|
||||
};
|
||||
|
||||
template<BOOST_PP_ENUM_PARAMS(N, typename E)>
|
||||
struct BOOST_PP_CAT(deduce_domain, N)
|
||||
: BOOST_PP_CAT(common_domain, N)<
|
||||
BOOST_PP_ENUM_BINARY_PARAMS(
|
||||
N
|
||||
, typename domain_of<E, >::type BOOST_PP_INTERCEPT
|
||||
)
|
||||
>
|
||||
{};
|
||||
|
||||
#undef N
|
||||
|
||||
#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES
|
||||
79
test/external/boost/proto/detail/deep_copy.hpp
vendored
Normal file
79
test/external/boost/proto/detail/deep_copy.hpp
vendored
Normal file
@@ -0,0 +1,79 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/deep_copy.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#define BOOST_PROTO_DEFINE_DEEP_COPY_TYPE(Z, N, DATA) \
|
||||
typename deep_copy_impl< \
|
||||
typename remove_reference< \
|
||||
typename Expr::BOOST_PP_CAT(proto_child, N) \
|
||||
>::type::proto_derived_expr \
|
||||
>::result_type \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_DEFINE_DEEP_COPY_FUN(Z, N, DATA) \
|
||||
proto::deep_copy(e.proto_base().BOOST_PP_CAT(child, N)) \
|
||||
/**/
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/deep_copy.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file deep_copy.hpp
|
||||
/// Replace all nodes stored by reference by nodes stored by value.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/deep_copy.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#undef BOOST_PROTO_DEFINE_DEEP_COPY_FUN
|
||||
#undef BOOST_PROTO_DEFINE_DEEP_COPY_TYPE
|
||||
|
||||
#else
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
template<typename Expr>
|
||||
struct deep_copy_impl<Expr, N>
|
||||
{
|
||||
typedef
|
||||
typename base_expr<
|
||||
typename Expr::proto_domain
|
||||
, typename Expr::proto_tag
|
||||
, BOOST_PP_CAT(list, N)<
|
||||
BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_DEEP_COPY_TYPE, ~)
|
||||
>
|
||||
>::type
|
||||
expr_type;
|
||||
|
||||
typedef typename Expr::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
|
||||
template<typename Expr2, typename S, typename D>
|
||||
result_type operator()(Expr2 const &e, S const &, D const &) const
|
||||
{
|
||||
expr_type const that = {
|
||||
BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_DEEP_COPY_FUN, ~)
|
||||
};
|
||||
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
|
||||
#undef N
|
||||
|
||||
#endif
|
||||
247
test/external/boost/proto/detail/deprecated.hpp
vendored
Normal file
247
test/external/boost/proto/detail/deprecated.hpp
vendored
Normal file
@@ -0,0 +1,247 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file deprecated.hpp
|
||||
/// Definition of the deprecated BOOST_PROTO_DEFINE_FUCTION_TEMPLATE and
|
||||
/// BOOST_PROTO_DEFINE_VARARG_FUCTION_TEMPLATE macros
|
||||
//
|
||||
// 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_DETAIL_DEPRECATED_HPP_EAN_11_25_2008
|
||||
#define BOOST_PROTO_DETAIL_DEPRECATED_HPP_EAN_11_25_2008
|
||||
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/facilities/intercept.hpp>
|
||||
#include <boost/preprocessor/arithmetic/inc.hpp>
|
||||
#include <boost/preprocessor/arithmetic/dec.hpp>
|
||||
#include <boost/preprocessor/arithmetic/sub.hpp>
|
||||
#include <boost/preprocessor/punctuation/comma_if.hpp>
|
||||
#include <boost/preprocessor/control/if.hpp>
|
||||
#include <boost/preprocessor/control/expr_if.hpp>
|
||||
#include <boost/preprocessor/comparison/greater.hpp>
|
||||
#include <boost/preprocessor/tuple/elem.hpp>
|
||||
#include <boost/preprocessor/tuple/to_list.hpp>
|
||||
#include <boost/preprocessor/logical/and.hpp>
|
||||
#include <boost/preprocessor/seq/size.hpp>
|
||||
#include <boost/preprocessor/seq/enum.hpp>
|
||||
#include <boost/preprocessor/seq/seq.hpp>
|
||||
#include <boost/preprocessor/seq/to_tuple.hpp>
|
||||
#include <boost/preprocessor/seq/for_each_i.hpp>
|
||||
#include <boost/preprocessor/seq/pop_back.hpp>
|
||||
#include <boost/preprocessor/seq/push_back.hpp>
|
||||
#include <boost/preprocessor/seq/push_front.hpp>
|
||||
#include <boost/preprocessor/list/for_each_i.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_VARARG_TEMPLATE_AUX_(R, DATA, I, ELEM) \
|
||||
(ELEM BOOST_PP_CAT(BOOST_PP_CAT(X, DATA), BOOST_PP_CAT(_, I))) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_VARARG_TEMPLATE_YES_(R, DATA, I, ELEM) \
|
||||
BOOST_PP_LIST_FOR_EACH_I_R( \
|
||||
R \
|
||||
, BOOST_PROTO_VARARG_TEMPLATE_AUX_ \
|
||||
, I \
|
||||
, BOOST_PP_TUPLE_TO_LIST( \
|
||||
BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM)) \
|
||||
, BOOST_PP_SEQ_TO_TUPLE(BOOST_PP_SEQ_TAIL(ELEM)) \
|
||||
) \
|
||||
) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_VARARG_TEMPLATE_NO_(R, DATA, I, ELEM) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_VARARG_TEMPLATE_(R, DATA, I, ELEM) \
|
||||
BOOST_PP_IF( \
|
||||
BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM)) \
|
||||
, BOOST_PROTO_VARARG_TEMPLATE_YES_ \
|
||||
, BOOST_PROTO_VARARG_TEMPLATE_NO_ \
|
||||
)(R, DATA, I, ELEM) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_VARARG_TYPE_AUX_(R, DATA, I, ELEM) \
|
||||
(BOOST_PP_CAT(BOOST_PP_CAT(X, DATA), BOOST_PP_CAT(_, I))) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_TEMPLATE_PARAMS_YES_(R, DATA, I, ELEM) \
|
||||
< \
|
||||
BOOST_PP_SEQ_ENUM( \
|
||||
BOOST_PP_LIST_FOR_EACH_I_R( \
|
||||
R \
|
||||
, BOOST_PROTO_VARARG_TYPE_AUX_ \
|
||||
, I \
|
||||
, BOOST_PP_TUPLE_TO_LIST( \
|
||||
BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM)) \
|
||||
, BOOST_PP_SEQ_TO_TUPLE(BOOST_PP_SEQ_TAIL(ELEM)) \
|
||||
) \
|
||||
) \
|
||||
) \
|
||||
> \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_TEMPLATE_PARAMS_NO_(R, DATA, I, ELEM) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_VARARG_TYPE_(R, DATA, I, ELEM) \
|
||||
BOOST_PP_COMMA_IF(I) \
|
||||
BOOST_PP_SEQ_HEAD(ELEM) \
|
||||
BOOST_PP_IF( \
|
||||
BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM)) \
|
||||
, BOOST_PROTO_TEMPLATE_PARAMS_YES_ \
|
||||
, BOOST_PROTO_TEMPLATE_PARAMS_NO_ \
|
||||
)(R, DATA, I, ELEM) BOOST_PP_EXPR_IF(BOOST_PP_GREATER(I, 1), const) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_VARARG_AS_EXPR_(R, DATA, I, ELEM) \
|
||||
BOOST_PP_EXPR_IF( \
|
||||
BOOST_PP_GREATER(I, 1) \
|
||||
, (( \
|
||||
BOOST_PP_SEQ_HEAD(ELEM) \
|
||||
BOOST_PP_IF( \
|
||||
BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM)) \
|
||||
, BOOST_PROTO_TEMPLATE_PARAMS_YES_ \
|
||||
, BOOST_PROTO_TEMPLATE_PARAMS_NO_ \
|
||||
)(R, DATA, I, ELEM)() \
|
||||
)) \
|
||||
) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_VARARG_AS_CHILD_(Z, N, DATA) \
|
||||
(BOOST_PP_CAT(DATA, N)) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_SEQ_PUSH_FRONT(SEQ, ELEM) \
|
||||
BOOST_PP_SEQ_POP_BACK(BOOST_PP_SEQ_PUSH_FRONT(BOOST_PP_SEQ_PUSH_BACK(SEQ, _dummy_), ELEM)) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_VARARG_AS_PARAM_(Z, N, DATA) \
|
||||
(BOOST_PP_CAT(DATA, N)) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_VARARG_FUN_(Z, N, DATA) \
|
||||
template< \
|
||||
BOOST_PP_SEQ_ENUM( \
|
||||
BOOST_PP_SEQ_FOR_EACH_I( \
|
||||
BOOST_PROTO_VARARG_TEMPLATE_, ~ \
|
||||
, BOOST_PP_SEQ_PUSH_FRONT( \
|
||||
BOOST_PROTO_SEQ_PUSH_FRONT( \
|
||||
BOOST_PP_TUPLE_ELEM(4, 2, DATA) \
|
||||
, (BOOST_PP_TUPLE_ELEM(4, 3, DATA)) \
|
||||
) \
|
||||
, BOOST_PP_TUPLE_ELEM(4, 1, DATA) \
|
||||
) \
|
||||
) \
|
||||
BOOST_PP_REPEAT_ ## Z(N, BOOST_PROTO_VARARG_AS_PARAM_, typename A) \
|
||||
) \
|
||||
> \
|
||||
typename boost::proto::result_of::make_expr< \
|
||||
BOOST_PP_SEQ_FOR_EACH_I( \
|
||||
BOOST_PROTO_VARARG_TYPE_, ~ \
|
||||
, BOOST_PP_SEQ_PUSH_FRONT( \
|
||||
BOOST_PROTO_SEQ_PUSH_FRONT( \
|
||||
BOOST_PP_TUPLE_ELEM(4, 2, DATA) \
|
||||
, (BOOST_PP_TUPLE_ELEM(4, 3, DATA)) \
|
||||
) \
|
||||
, BOOST_PP_TUPLE_ELEM(4, 1, DATA) \
|
||||
) \
|
||||
) \
|
||||
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(Z, N, A, const & BOOST_PP_INTERCEPT) \
|
||||
>::type const \
|
||||
BOOST_PP_TUPLE_ELEM(4, 0, DATA)(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a)) \
|
||||
{ \
|
||||
return boost::proto::detail::make_expr_< \
|
||||
BOOST_PP_SEQ_FOR_EACH_I( \
|
||||
BOOST_PROTO_VARARG_TYPE_, ~ \
|
||||
, BOOST_PP_SEQ_PUSH_FRONT( \
|
||||
BOOST_PROTO_SEQ_PUSH_FRONT( \
|
||||
BOOST_PP_TUPLE_ELEM(4, 2, DATA) \
|
||||
, (BOOST_PP_TUPLE_ELEM(4, 3, DATA)) \
|
||||
) \
|
||||
, BOOST_PP_TUPLE_ELEM(4, 1, DATA) \
|
||||
) \
|
||||
) \
|
||||
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(Z, N, A, const & BOOST_PP_INTERCEPT) \
|
||||
>()( \
|
||||
BOOST_PP_SEQ_ENUM( \
|
||||
BOOST_PP_SEQ_FOR_EACH_I( \
|
||||
BOOST_PROTO_VARARG_AS_EXPR_, ~ \
|
||||
, BOOST_PP_SEQ_PUSH_FRONT( \
|
||||
BOOST_PROTO_SEQ_PUSH_FRONT( \
|
||||
BOOST_PP_TUPLE_ELEM(4, 2, DATA) \
|
||||
, (BOOST_PP_TUPLE_ELEM(4, 3, DATA)) \
|
||||
) \
|
||||
, BOOST_PP_TUPLE_ELEM(4, 1, DATA) \
|
||||
) \
|
||||
) \
|
||||
BOOST_PP_REPEAT_ ## Z(N, BOOST_PROTO_VARARG_AS_CHILD_, a) \
|
||||
) \
|
||||
); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
/// \code
|
||||
/// BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(
|
||||
/// 1
|
||||
/// , construct
|
||||
/// , boost::proto::default_domain
|
||||
/// , (boost::proto::tag::function)
|
||||
/// , ((op::construct)(typename)(int))
|
||||
/// )
|
||||
/// \endcode
|
||||
#define BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(ARGCOUNT, NAME, DOMAIN, TAG, BOUNDARGS) \
|
||||
BOOST_PP_REPEAT_FROM_TO( \
|
||||
ARGCOUNT \
|
||||
, BOOST_PP_INC(ARGCOUNT) \
|
||||
, BOOST_PROTO_VARARG_FUN_ \
|
||||
, (NAME, TAG, BOUNDARGS, DOMAIN) \
|
||||
)\
|
||||
/**/
|
||||
|
||||
/// \code
|
||||
/// BOOST_PROTO_DEFINE_VARARG_FUNCTION_TEMPLATE(
|
||||
/// construct
|
||||
/// , boost::proto::default_domain
|
||||
/// , (boost::proto::tag::function)
|
||||
/// , ((op::construct)(typename)(int))
|
||||
/// )
|
||||
/// \endcode
|
||||
#define BOOST_PROTO_DEFINE_VARARG_FUNCTION_TEMPLATE(NAME, DOMAIN, TAG, BOUNDARGS) \
|
||||
BOOST_PP_REPEAT( \
|
||||
BOOST_PP_SUB(BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), BOOST_PP_SEQ_SIZE(BOUNDARGS)) \
|
||||
, BOOST_PROTO_VARARG_FUN_ \
|
||||
, (NAME, TAG, BOUNDARGS, DOMAIN) \
|
||||
) \
|
||||
/**/
|
||||
|
||||
#endif
|
||||
23
test/external/boost/proto/detail/dont_care.hpp
vendored
Normal file
23
test/external/boost/proto/detail/dont_care.hpp
vendored
Normal file
@@ -0,0 +1,23 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file dont_care.hpp
|
||||
/// Definintion of dont_care, a dummy parameter
|
||||
//
|
||||
// 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_DETAIL_DONT_CARE_HPP_EAN_11_07_2007
|
||||
#define BOOST_PROTO_DETAIL_DONT_CARE_HPP_EAN_11_07_2007
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
struct dont_care
|
||||
{
|
||||
dont_care(...);
|
||||
};
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
455
test/external/boost/proto/detail/expr.hpp
vendored
Normal file
455
test/external/boost/proto/detail/expr.hpp
vendored
Normal file
@@ -0,0 +1,455 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#ifndef BOOST_NO_VARIADIC_TEMPLATES
|
||||
#include <boost/proto/detail/preprocessed/expr_variadic.hpp>
|
||||
#else
|
||||
#include <boost/proto/detail/preprocessed/expr.hpp>
|
||||
#endif
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_CHILD(Z, N, DATA) \
|
||||
typedef BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(proto_child, N); \
|
||||
BOOST_PP_CAT(proto_child, N) BOOST_PP_CAT(child, N); \
|
||||
/**< INTERNAL ONLY */
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_VOID(Z, N, DATA) \
|
||||
typedef void BOOST_PP_CAT(proto_child, N); \
|
||||
/**< INTERNAL ONLY */
|
||||
|
||||
// Generate variadic versions of expr
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/expr_variadic.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file expr_variadic.hpp
|
||||
/// Contains definition of expr\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
// The expr<> specializations are actually defined here.
|
||||
#define BOOST_PROTO_DEFINE_TERMINAL
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (0, 0, <boost/proto/detail/expr.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#undef BOOST_PROTO_DEFINE_TERMINAL
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/expr.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
// Generate non-variadic versions of expr
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#define BOOST_NO_VARIADIC_TEMPLATES
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/expr.hpp")
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file expr.hpp
|
||||
/// Contains definition of expr\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#pragma wave option(preserve: 1)
|
||||
|
||||
// The expr<> specializations are actually defined here.
|
||||
#define BOOST_PROTO_DEFINE_TERMINAL
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 (3, (0, 0, <boost/proto/detail/expr.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#undef BOOST_PROTO_DEFINE_TERMINAL
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/expr.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#pragma wave option(output: null)
|
||||
#undef BOOST_NO_VARIADIC_TEMPLATES
|
||||
#endif
|
||||
|
||||
#undef BOOST_PROTO_CHILD
|
||||
#undef BOOST_PROTO_VOID
|
||||
|
||||
#else
|
||||
|
||||
#define ARG_COUNT BOOST_PP_MAX(1, BOOST_PP_ITERATION())
|
||||
|
||||
/// \brief Representation of a node in an expression tree.
|
||||
///
|
||||
/// \c proto::expr\<\> is a node in an expression template tree. It
|
||||
/// is a container for its child sub-trees. It also serves as
|
||||
/// the terminal nodes of the tree.
|
||||
///
|
||||
/// \c Tag is type that represents the operation encoded by
|
||||
/// this expression. It is typically one of the structs
|
||||
/// in the \c boost::proto::tag namespace, but it doesn't
|
||||
/// have to be.
|
||||
///
|
||||
/// \c Args is a type list representing the type of the children
|
||||
/// of this expression. It is an instantiation of one
|
||||
/// of \c proto::list1\<\>, \c proto::list2\<\>, etc. The
|
||||
/// child types must all themselves be either \c expr\<\>
|
||||
/// or <tt>proto::expr\<\>&</tt>. If \c Args is an
|
||||
/// instantiation of \c proto::term\<\> then this
|
||||
/// \c expr\<\> type represents a terminal expression;
|
||||
/// the parameter to the \c proto::term\<\> template
|
||||
/// represents the terminal's value type.
|
||||
///
|
||||
/// \c Arity is an integral constant representing the number of child
|
||||
/// nodes this node contains. If \c Arity is 0, then this
|
||||
/// node is a terminal.
|
||||
///
|
||||
/// \c proto::expr\<\> is a valid Fusion random-access sequence, where
|
||||
/// the elements of the sequence are the child expressions.
|
||||
#ifdef BOOST_PROTO_DEFINE_TERMINAL
|
||||
template<typename Tag, typename Arg0>
|
||||
struct expr<Tag, term<Arg0>, 0>
|
||||
#else
|
||||
template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(ARG_COUNT, typename Arg)>
|
||||
struct expr<Tag, BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)>, BOOST_PP_ITERATION() >
|
||||
#endif
|
||||
{
|
||||
typedef Tag proto_tag;
|
||||
static const long proto_arity_c = BOOST_PP_ITERATION();
|
||||
typedef mpl::long_<BOOST_PP_ITERATION() > proto_arity;
|
||||
typedef expr proto_base_expr;
|
||||
#ifdef BOOST_PROTO_DEFINE_TERMINAL
|
||||
typedef term<Arg0> proto_args;
|
||||
#else
|
||||
typedef BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)> proto_args;
|
||||
#endif
|
||||
typedef basic_expr<Tag, proto_args, BOOST_PP_ITERATION() > proto_grammar;
|
||||
typedef default_domain proto_domain;
|
||||
typedef default_generator proto_generator;
|
||||
typedef proto::tag::proto_expr fusion_tag;
|
||||
typedef expr proto_derived_expr;
|
||||
typedef void proto_is_expr_; /**< INTERNAL ONLY */
|
||||
|
||||
BOOST_PP_REPEAT(ARG_COUNT, BOOST_PROTO_CHILD, ~)
|
||||
BOOST_PP_REPEAT_FROM_TO(ARG_COUNT, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_VOID, ~)
|
||||
|
||||
/// \return *this
|
||||
///
|
||||
expr const &proto_base() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
///
|
||||
expr &proto_base()
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
#ifdef BOOST_PROTO_DEFINE_TERMINAL
|
||||
/// \return A new \c expr\<\> object initialized with the specified
|
||||
/// arguments.
|
||||
///
|
||||
template<typename A0>
|
||||
static expr const make(A0 &a0)
|
||||
{
|
||||
return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0));
|
||||
}
|
||||
|
||||
/// \overload
|
||||
///
|
||||
template<typename A0>
|
||||
static expr const make(A0 const &a0)
|
||||
{
|
||||
return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0));
|
||||
}
|
||||
#else
|
||||
/// \return A new \c expr\<\> object initialized with the specified
|
||||
/// arguments.
|
||||
///
|
||||
template<BOOST_PP_ENUM_PARAMS(ARG_COUNT, typename A)>
|
||||
static expr const make(BOOST_PP_ENUM_BINARY_PARAMS(ARG_COUNT, A, const &a))
|
||||
{
|
||||
expr that = {BOOST_PP_ENUM_PARAMS(ARG_COUNT, a)};
|
||||
return that;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if 1 == BOOST_PP_ITERATION()
|
||||
/// If \c Tag is \c boost::proto::tag::address_of and \c proto_child0 is
|
||||
/// <tt>T&</tt>, then \c address_of_hack_type_ is <tt>T*</tt>.
|
||||
/// Otherwise, it is some undefined type.
|
||||
typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_;
|
||||
|
||||
/// \return The address of <tt>this->child0</tt> if \c Tag is
|
||||
/// \c boost::proto::tag::address_of. Otherwise, this function will
|
||||
/// fail to compile.
|
||||
///
|
||||
/// \attention Proto overloads <tt>operator&</tt>, which means that
|
||||
/// proto-ified objects cannot have their addresses taken, unless we use
|
||||
/// the following hack to make \c &x implicitly convertible to \c X*.
|
||||
operator address_of_hack_type_() const
|
||||
{
|
||||
return boost::addressof(this->child0);
|
||||
}
|
||||
#else
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef detail::not_a_valid_type address_of_hack_type_;
|
||||
#endif
|
||||
|
||||
/// Assignment
|
||||
///
|
||||
/// \param a The rhs.
|
||||
/// \return A new \c expr\<\> node representing an assignment of \c that to \c *this.
|
||||
proto::expr<
|
||||
proto::tag::assign
|
||||
, list2<expr &, expr const &>
|
||||
, 2
|
||||
> const
|
||||
operator =(expr const &a)
|
||||
{
|
||||
proto::expr<
|
||||
proto::tag::assign
|
||||
, list2<expr &, expr const &>
|
||||
, 2
|
||||
> that = {*this, a};
|
||||
return that;
|
||||
}
|
||||
|
||||
/// Assignment
|
||||
///
|
||||
/// \param a The rhs.
|
||||
/// \return A new \c expr\<\> node representing an assignment of \c a to \c *this.
|
||||
template<typename A>
|
||||
proto::expr<
|
||||
proto::tag::assign
|
||||
, list2<expr const &, typename result_of::as_child<A>::type>
|
||||
, 2
|
||||
> const
|
||||
operator =(A &a) const
|
||||
{
|
||||
proto::expr<
|
||||
proto::tag::assign
|
||||
, list2<expr const &, typename result_of::as_child<A>::type>
|
||||
, 2
|
||||
> that = {*this, proto::as_child(a)};
|
||||
return that;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
///
|
||||
template<typename A>
|
||||
proto::expr<
|
||||
proto::tag::assign
|
||||
, list2<expr const &, typename result_of::as_child<A const>::type>
|
||||
, 2
|
||||
> const
|
||||
operator =(A const &a) const
|
||||
{
|
||||
proto::expr<
|
||||
proto::tag::assign
|
||||
, list2<expr const &, typename result_of::as_child<A const>::type>
|
||||
, 2
|
||||
> that = {*this, proto::as_child(a)};
|
||||
return that;
|
||||
}
|
||||
|
||||
#ifdef BOOST_PROTO_DEFINE_TERMINAL
|
||||
/// \overload
|
||||
///
|
||||
template<typename A>
|
||||
proto::expr<
|
||||
proto::tag::assign
|
||||
, list2<expr &, typename result_of::as_child<A>::type>
|
||||
, 2
|
||||
> const
|
||||
operator =(A &a)
|
||||
{
|
||||
proto::expr<
|
||||
proto::tag::assign
|
||||
, list2<expr &, typename result_of::as_child<A>::type>
|
||||
, 2
|
||||
> that = {*this, proto::as_child(a)};
|
||||
return that;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
///
|
||||
template<typename A>
|
||||
proto::expr<
|
||||
proto::tag::assign
|
||||
, list2<expr &, typename result_of::as_child<A const>::type>
|
||||
, 2
|
||||
> const
|
||||
operator =(A const &a)
|
||||
{
|
||||
proto::expr<
|
||||
proto::tag::assign
|
||||
, list2<expr &, typename result_of::as_child<A const>::type>
|
||||
, 2
|
||||
> that = {*this, proto::as_child(a)};
|
||||
return that;
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Subscript
|
||||
///
|
||||
/// \param a The rhs.
|
||||
/// \return A new \c expr\<\> node representing \c *this subscripted with \c a.
|
||||
template<typename A>
|
||||
proto::expr<
|
||||
proto::tag::subscript
|
||||
, list2<expr const &, typename result_of::as_child<A>::type>
|
||||
, 2
|
||||
> const
|
||||
operator [](A &a) const
|
||||
{
|
||||
proto::expr<
|
||||
proto::tag::subscript
|
||||
, list2<expr const &, typename result_of::as_child<A>::type>
|
||||
, 2
|
||||
> that = {*this, proto::as_child(a)};
|
||||
return that;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
///
|
||||
template<typename A>
|
||||
proto::expr<
|
||||
proto::tag::subscript
|
||||
, list2<expr const &, typename result_of::as_child<A const>::type>
|
||||
, 2
|
||||
> const
|
||||
operator [](A const &a) const
|
||||
{
|
||||
proto::expr<
|
||||
proto::tag::subscript
|
||||
, list2<expr const &, typename result_of::as_child<A const>::type>
|
||||
, 2
|
||||
> that = {*this, proto::as_child(a)};
|
||||
return that;
|
||||
}
|
||||
|
||||
#ifdef BOOST_PROTO_DEFINE_TERMINAL
|
||||
/// \overload
|
||||
///
|
||||
template<typename A>
|
||||
proto::expr<
|
||||
proto::tag::subscript
|
||||
, list2<expr &, typename result_of::as_child<A>::type>
|
||||
, 2
|
||||
> const
|
||||
operator [](A &a)
|
||||
{
|
||||
proto::expr<
|
||||
proto::tag::subscript
|
||||
, list2<expr &, typename result_of::as_child<A>::type>
|
||||
, 2
|
||||
> that = {*this, proto::as_child(a)};
|
||||
return that;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
///
|
||||
template<typename A>
|
||||
proto::expr<
|
||||
proto::tag::subscript
|
||||
, list2<expr &, typename result_of::as_child<A const>::type>
|
||||
, 2
|
||||
> const
|
||||
operator [](A const &a)
|
||||
{
|
||||
proto::expr<
|
||||
proto::tag::subscript
|
||||
, list2<expr &, typename result_of::as_child<A const>::type>
|
||||
, 2
|
||||
> that = {*this, proto::as_child(a)};
|
||||
return that;
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Encodes the return type of \c expr\<\>::operator(), for use with \c boost::result_of\<\>
|
||||
///
|
||||
template<typename Sig>
|
||||
struct result
|
||||
{
|
||||
typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
|
||||
};
|
||||
|
||||
#ifndef BOOST_NO_VARIADIC_TEMPLATES
|
||||
/// \overload
|
||||
///
|
||||
template<typename ...A>
|
||||
typename result_of::funop<
|
||||
expr const(A const &...)
|
||||
, expr
|
||||
, default_domain
|
||||
>::type const
|
||||
operator ()(A const &... a) const
|
||||
{
|
||||
return result_of::funop<
|
||||
expr const(A const &...)
|
||||
, expr
|
||||
, default_domain
|
||||
>::call(*this, a...);
|
||||
}
|
||||
|
||||
#ifdef BOOST_PROTO_DEFINE_TERMINAL
|
||||
/// \overload
|
||||
///
|
||||
template<typename ...A>
|
||||
typename result_of::funop<
|
||||
expr(A const &...)
|
||||
, expr
|
||||
, default_domain
|
||||
>::type const
|
||||
operator ()(A const &... a)
|
||||
{
|
||||
return result_of::funop<
|
||||
expr(A const &...)
|
||||
, expr
|
||||
, default_domain
|
||||
>::call(*this, a...);
|
||||
}
|
||||
#endif
|
||||
|
||||
#else // BOOST_NO_VARIADIC_TEMPLATES
|
||||
|
||||
/// Function call
|
||||
///
|
||||
/// \return A new \c expr\<\> node representing the function invocation of \c (*this)().
|
||||
proto::expr<proto::tag::function, list1<expr const &>, 1> const
|
||||
operator ()() const
|
||||
{
|
||||
proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
|
||||
return that;
|
||||
}
|
||||
|
||||
#ifdef BOOST_PROTO_DEFINE_TERMINAL
|
||||
/// \overload
|
||||
///
|
||||
proto::expr<proto::tag::function, list1<expr &>, 1> const
|
||||
operator ()()
|
||||
{
|
||||
proto::expr<proto::tag::function, list1<expr &>, 1> that = {*this};
|
||||
return that;
|
||||
}
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_2 \
|
||||
(3, (1, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY), <boost/proto/detail/expr_funop.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#endif
|
||||
};
|
||||
|
||||
#undef ARG_COUNT
|
||||
|
||||
#endif
|
||||
43
test/external/boost/proto/detail/expr_funop.hpp
vendored
Normal file
43
test/external/boost/proto/detail/expr_funop.hpp
vendored
Normal file
@@ -0,0 +1,43 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// expr1.hpp
|
||||
// Contains definition of expr\<\>::operator() overloads.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
/// \overload
|
||||
///
|
||||
template<BOOST_PP_ENUM_PARAMS(N, typename A)>
|
||||
typename result_of::BOOST_PP_CAT(funop, N)<
|
||||
expr const
|
||||
, default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
|
||||
>::type const
|
||||
operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a)) const
|
||||
{
|
||||
return result_of::BOOST_PP_CAT(funop, N)<
|
||||
expr const
|
||||
, default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
|
||||
>::call(*this BOOST_PP_ENUM_TRAILING_PARAMS(N, a));
|
||||
}
|
||||
|
||||
#ifdef BOOST_PROTO_DEFINE_TERMINAL
|
||||
/// \overload
|
||||
///
|
||||
template<BOOST_PP_ENUM_PARAMS(N, typename A)>
|
||||
typename result_of::BOOST_PP_CAT(funop, N)<
|
||||
expr
|
||||
, default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
|
||||
>::type const
|
||||
operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a))
|
||||
{
|
||||
return result_of::BOOST_PP_CAT(funop, N)<
|
||||
expr
|
||||
, default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
|
||||
>::call(*this BOOST_PP_ENUM_TRAILING_PARAMS(N, a));
|
||||
}
|
||||
#endif
|
||||
|
||||
#undef N
|
||||
43
test/external/boost/proto/detail/extends_funop.hpp
vendored
Normal file
43
test/external/boost/proto/detail/extends_funop.hpp
vendored
Normal file
@@ -0,0 +1,43 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#ifndef BOOST_NO_VARIADIC_TEMPLATES
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_()
|
||||
BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY)
|
||||
BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST)
|
||||
#else
|
||||
#include <boost/proto/detail/preprocessed/extends_funop.hpp>
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
#define BOOST_PP_LOCAL_MACRO(N) \
|
||||
BOOST_PROTO_DEFINE_FUN_OP(1, N, ~) \
|
||||
/**/
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) && !defined(BOOST_PROTO_NO_WAVE_OUTPUT)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/extends_funop.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file extends_funop.hpp
|
||||
/// Definitions for extends\<\>::operator()
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) && !defined(BOOST_PROTO_NO_WAVE_OUTPUT)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_()
|
||||
|
||||
#define BOOST_PP_LOCAL_LIMITS \
|
||||
(0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY))
|
||||
#include BOOST_PP_LOCAL_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) && !defined(BOOST_PROTO_NO_WAVE_OUTPUT)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
42
test/external/boost/proto/detail/extends_funop_const.hpp
vendored
Normal file
42
test/external/boost/proto/detail/extends_funop_const.hpp
vendored
Normal file
@@ -0,0 +1,42 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#ifndef BOOST_NO_VARIADIC_TEMPLATES
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_()
|
||||
BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST)
|
||||
#else
|
||||
#include <boost/proto/detail/preprocessed/extends_funop_const.hpp>
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
#define BOOST_PP_LOCAL_MACRO(N) \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_CONST(1, N, ~) \
|
||||
/**/
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/extends_funop_const.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file extends_funop_const.hpp
|
||||
/// Definitions for extends\<\>::operator()
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_()
|
||||
|
||||
#define BOOST_PP_LOCAL_LIMITS \
|
||||
(0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY))
|
||||
#include BOOST_PP_LOCAL_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
86
test/external/boost/proto/detail/funop.hpp
vendored
Normal file
86
test/external/boost/proto/detail/funop.hpp
vendored
Normal file
@@ -0,0 +1,86 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/funop.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#define BOOST_PROTO_AS_CHILD_TYPE(Z, N, DATA) \
|
||||
typename proto::result_of::as_child<BOOST_PP_CAT(A, N), Domain>::type \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_AS_CHILD(Z, N, DATA) \
|
||||
proto::as_child<Domain>(BOOST_PP_CAT(a, N)) \
|
||||
/**/
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/funop.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// funop.hpp
|
||||
// Contains definition of funop[n]\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY), <boost/proto/detail/funop.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#undef BOOST_PROTO_AS_CHILD
|
||||
#undef BOOST_PROTO_AS_CHILD_TYPE
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
/// \brief A helper metafunction for computing the
|
||||
/// return type of \c proto::expr\<\>::operator().
|
||||
template<typename Expr, typename Domain BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename A)>
|
||||
struct BOOST_PP_CAT(funop, BOOST_PP_ITERATION())
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, BOOST_PP_CAT(list, BOOST_PP_INC(BOOST_PP_ITERATION()))<
|
||||
Expr &
|
||||
BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), BOOST_PROTO_AS_CHILD_TYPE, ~)
|
||||
>
|
||||
>::type type;
|
||||
|
||||
static type const call(
|
||||
Expr &e
|
||||
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(BOOST_PP_ITERATION(), A, &a)
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), BOOST_PROTO_AS_CHILD, ~)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
/// \brief A helper metafunction for computing the
|
||||
/// return type of \c proto::expr\<\>::operator().
|
||||
template<typename Expr BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename A), typename This, typename Domain>
|
||||
struct funop<Expr(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), This, Domain>
|
||||
: BOOST_PP_CAT(funop, BOOST_PP_ITERATION())<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(
|
||||
BOOST_PP_ITERATION()
|
||||
, typename remove_reference<A
|
||||
, >::type BOOST_PP_INTERCEPT
|
||||
)
|
||||
>
|
||||
{};
|
||||
|
||||
#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES
|
||||
91
test/external/boost/proto/detail/generate_by_value.hpp
vendored
Normal file
91
test/external/boost/proto/detail/generate_by_value.hpp
vendored
Normal file
@@ -0,0 +1,91 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/generate_by_value.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/generate_by_value.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file generate_by_value.hpp
|
||||
/// Contains definition of by_value_generator_\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/generate_by_value.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#else // BOOST_PP_IS_ITERATING
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Arg) >
|
||||
struct by_value_generator_<
|
||||
proto::expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, Arg)>, N>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, Arg)>
|
||||
src_args;
|
||||
|
||||
typedef
|
||||
BOOST_PP_CAT(list, N)<
|
||||
BOOST_PP_ENUM_BINARY_PARAMS(N, typename uncvref<Arg, >::type BOOST_PP_INTERCEPT)
|
||||
>
|
||||
dst_args;
|
||||
|
||||
typedef proto::expr<Tag, src_args, N> src_type;
|
||||
typedef proto::expr<Tag, dst_args, N> type;
|
||||
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
BOOST_PP_ENUM_PARAMS(N, e.child)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Arg) >
|
||||
struct by_value_generator_<
|
||||
proto::basic_expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, Arg)>, N>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, Arg)>
|
||||
src_args;
|
||||
|
||||
typedef
|
||||
BOOST_PP_CAT(list, N)<
|
||||
BOOST_PP_ENUM_BINARY_PARAMS(N, typename uncvref<Arg, >::type BOOST_PP_INTERCEPT)
|
||||
>
|
||||
dst_args;
|
||||
|
||||
typedef proto::basic_expr<Tag, src_args, N> src_type;
|
||||
typedef proto::basic_expr<Tag, dst_args, N> type;
|
||||
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
BOOST_PP_ENUM_PARAMS(N, e.child)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
#undef N
|
||||
|
||||
#endif
|
||||
23
test/external/boost/proto/detail/ignore_unused.hpp
vendored
Normal file
23
test/external/boost/proto/detail/ignore_unused.hpp
vendored
Normal file
@@ -0,0 +1,23 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file ignore_unused.hpp
|
||||
/// Definintion of ignore_unused, a dummy function for suppressing compiler
|
||||
/// warnings
|
||||
//
|
||||
// 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_DETAIL_IGNORE_UNUSED_HPP_EAN_03_03_2008
|
||||
#define BOOST_PROTO_DETAIL_IGNORE_UNUSED_HPP_EAN_03_03_2008
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
template<typename T>
|
||||
inline void ignore_unused(T const &)
|
||||
{}
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
61
test/external/boost/proto/detail/lambda_matches.hpp
vendored
Normal file
61
test/external/boost/proto/detail/lambda_matches.hpp
vendored
Normal file
@@ -0,0 +1,61 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/lambda_matches.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#define BOOST_PROTO_DEFINE_LAMBDA_MATCHES(Z, N, DATA) \
|
||||
lambda_matches< \
|
||||
BOOST_PP_CAT(Expr, N) \
|
||||
, BOOST_PP_CAT(Grammar, N) \
|
||||
>
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/lambda_matches.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file lambda_matches.hpp
|
||||
/// Specializations of the lambda_matches template
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/lambda_matches.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#undef BOOST_PROTO_DEFINE_LAMBDA_MATCHES
|
||||
|
||||
#else // BOOST_PP_IS_ITERATING
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
template<
|
||||
template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class T
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Expr)
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Grammar)
|
||||
>
|
||||
struct lambda_matches<
|
||||
T<BOOST_PP_ENUM_PARAMS(N, Expr)>
|
||||
, T<BOOST_PP_ENUM_PARAMS(N, Grammar)>
|
||||
BOOST_PROTO_TEMPLATE_ARITY_PARAM(N)
|
||||
>
|
||||
: BOOST_PP_CAT(and_, N)<
|
||||
BOOST_PROTO_DEFINE_LAMBDA_MATCHES(~, 0, ~)::value,
|
||||
BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFINE_LAMBDA_MATCHES, ~)
|
||||
>
|
||||
{};
|
||||
|
||||
#undef N
|
||||
|
||||
#endif
|
||||
52
test/external/boost/proto/detail/local.hpp
vendored
Normal file
52
test/external/boost/proto/detail/local.hpp
vendored
Normal file
@@ -0,0 +1,52 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file local.hpp
|
||||
/// Contains macros to ease the generation of repetitious code constructs
|
||||
//
|
||||
// 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_LOCAL_MACRO
|
||||
# error "local iteration target macro is not defined"
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_PROTO_LOCAL_LIMITS
|
||||
# define BOOST_PROTO_LOCAL_LIMITS (1, BOOST_PROTO_MAX_ARITY)
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_PROTO_LOCAL_typename_A
|
||||
# define BOOST_PROTO_LOCAL_typename_A BOOST_PROTO_typename_A
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_PROTO_LOCAL_A
|
||||
# define BOOST_PROTO_LOCAL_A BOOST_PROTO_A_const_ref
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_PROTO_LOCAL_A_a
|
||||
# define BOOST_PROTO_LOCAL_A_a BOOST_PROTO_A_const_ref_a
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_PROTO_LOCAL_a
|
||||
# define BOOST_PROTO_LOCAL_a BOOST_PROTO_ref_a
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_LOCAL_LIMITS BOOST_PROTO_LOCAL_LIMITS
|
||||
|
||||
#define BOOST_PP_LOCAL_MACRO(N) \
|
||||
BOOST_PROTO_LOCAL_MACRO( \
|
||||
N \
|
||||
, BOOST_PROTO_LOCAL_typename_A \
|
||||
, BOOST_PROTO_LOCAL_A \
|
||||
, BOOST_PROTO_LOCAL_A_a \
|
||||
, BOOST_PROTO_LOCAL_a \
|
||||
) \
|
||||
/**/
|
||||
|
||||
#include BOOST_PP_LOCAL_ITERATE()
|
||||
|
||||
#undef BOOST_PROTO_LOCAL_MACRO
|
||||
#undef BOOST_PROTO_LOCAL_LIMITS
|
||||
#undef BOOST_PROTO_LOCAL_typename_A
|
||||
#undef BOOST_PROTO_LOCAL_A
|
||||
#undef BOOST_PROTO_LOCAL_A_a
|
||||
#undef BOOST_PROTO_LOCAL_a
|
||||
73
test/external/boost/proto/detail/make_expr.hpp
vendored
Normal file
73
test/external/boost/proto/detail/make_expr.hpp
vendored
Normal file
@@ -0,0 +1,73 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/make_expr.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_expr.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file make_expr.hpp
|
||||
/// Contains overloads of make_expr() free function.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/make_expr.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#else // BOOST_PP_IS_ITERATING
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
/// \overload
|
||||
///
|
||||
template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
|
||||
typename lazy_disable_if<
|
||||
is_domain<A0>
|
||||
, result_of::make_expr<
|
||||
Tag
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
|
||||
>
|
||||
>::type const
|
||||
make_expr(BOOST_PP_ENUM_BINARY_PARAMS(N, const A, &a))
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, deduce_domain
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
|
||||
>()(BOOST_PP_ENUM_PARAMS(N, a));
|
||||
}
|
||||
|
||||
/// \overload
|
||||
///
|
||||
template<typename Tag, typename Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, typename C)>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, const C)
|
||||
>::type const
|
||||
make_expr(BOOST_PP_ENUM_BINARY_PARAMS(N, const C, &c))
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, const C)
|
||||
>()(BOOST_PP_ENUM_PARAMS(N, c));
|
||||
}
|
||||
|
||||
#undef N
|
||||
|
||||
#endif
|
||||
103
test/external/boost/proto/detail/make_expr_.hpp
vendored
Normal file
103
test/external/boost/proto/detail/make_expr_.hpp
vendored
Normal file
@@ -0,0 +1,103 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/make_expr_.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_expr_.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file make_expr_.hpp
|
||||
/// Contains definition of make_expr_\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
template<
|
||||
typename Tag
|
||||
, typename Domain
|
||||
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(
|
||||
BOOST_PROTO_MAX_ARITY
|
||||
, typename A
|
||||
, = void BOOST_PP_INTERCEPT
|
||||
)
|
||||
, typename _ = void
|
||||
>
|
||||
struct make_expr_
|
||||
{};
|
||||
|
||||
template<typename Domain, typename A>
|
||||
struct make_expr_<tag::terminal, Domain, A
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, void BOOST_PP_INTERCEPT)>
|
||||
{
|
||||
typedef typename proto::detail::protoify<A, Domain>::result_type result_type;
|
||||
|
||||
result_type operator()(typename add_reference<A>::type a) const
|
||||
{
|
||||
return proto::detail::protoify<A, Domain>()(a);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename A>
|
||||
struct make_expr_<tag::terminal, deduce_domain, A
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, void BOOST_PP_INTERCEPT)>
|
||||
: make_expr_<tag::terminal, default_domain, A>
|
||||
{};
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/make_expr_.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#else // BOOST_PP_IS_ITERATING
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
#define M BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N)
|
||||
|
||||
template<typename Tag, typename Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
|
||||
struct make_expr_<Tag, Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(M, void BOOST_PP_INTERCEPT), void>
|
||||
{
|
||||
typedef
|
||||
BOOST_PP_CAT(list, N)<
|
||||
BOOST_PP_ENUM(N, BOOST_PROTO_AS_CHILD_TYPE, (A, ~, Domain))
|
||||
>
|
||||
proto_args;
|
||||
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
|
||||
result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<A, >::type a)) const
|
||||
{
|
||||
expr_type const that = {
|
||||
BOOST_PP_ENUM(N, BOOST_PROTO_AS_CHILD, (A, a, Domain))
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
|
||||
struct make_expr_<Tag, deduce_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(M, void BOOST_PP_INTERCEPT), void>
|
||||
: make_expr_<
|
||||
Tag
|
||||
, typename BOOST_PP_CAT(deduce_domain, N)<BOOST_PP_ENUM_PARAMS(N, A)>::type
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
|
||||
>
|
||||
{};
|
||||
|
||||
#undef N
|
||||
#undef M
|
||||
|
||||
#endif
|
||||
66
test/external/boost/proto/detail/make_expr_funop.hpp
vendored
Normal file
66
test/external/boost/proto/detail/make_expr_funop.hpp
vendored
Normal file
@@ -0,0 +1,66 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/make_expr_funop.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_expr_funop.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file make_expr_funop.hpp
|
||||
/// Contains definition of make_expr\<\>::operator() member functions.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/make_expr_funop.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#else // BOOST_PP_IS_ITERATING
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
template<typename This BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
|
||||
struct result<This(BOOST_PP_ENUM_PARAMS(N, A))>
|
||||
{
|
||||
typedef
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
/// \overload
|
||||
///
|
||||
template<BOOST_PP_ENUM_PARAMS(N, typename A)>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
|
||||
>::type const
|
||||
operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, const A, &a)) const
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
|
||||
>()(BOOST_PP_ENUM_PARAMS(N, a));
|
||||
}
|
||||
|
||||
#undef N
|
||||
|
||||
#endif
|
||||
96
test/external/boost/proto/detail/matches_.hpp
vendored
Normal file
96
test/external/boost/proto/detail/matches_.hpp
vendored
Normal file
@@ -0,0 +1,96 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/matches_.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#define BOOST_PROTO_MATCHES_N_FUN(Z, N, DATA) \
|
||||
matches_< \
|
||||
typename detail::expr_traits<typename Args1::BOOST_PP_CAT(child, N)>::value_type::proto_derived_expr \
|
||||
, typename detail::expr_traits<typename Args1::BOOST_PP_CAT(child, N)>::value_type::proto_grammar \
|
||||
, typename Args2::BOOST_PP_CAT(child, N)::proto_grammar \
|
||||
>
|
||||
|
||||
#define BOOST_PROTO_DEFINE_MATCHES(Z, N, DATA) \
|
||||
matches_< \
|
||||
Expr \
|
||||
, BasicExpr \
|
||||
, typename BOOST_PP_CAT(G, N)::proto_grammar \
|
||||
>
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/matches_.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file matches_.hpp
|
||||
/// Definitions of matches_ specializations
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (2, BOOST_PP_MAX(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_MAX_LOGICAL_ARITY), <boost/proto/detail/matches_.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#undef BOOST_PROTO_DEFINE_MATCHES
|
||||
#undef BOOST_PROTO_MATCHES_N_FUN
|
||||
|
||||
#else // BOOST_PP_IS_ITERATING
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
#if N <= BOOST_PROTO_MAX_LOGICAL_ARITY
|
||||
|
||||
// handle proto::or_
|
||||
template<typename Expr, typename BasicExpr BOOST_PP_ENUM_TRAILING_PARAMS(N, typename G)>
|
||||
struct matches_<Expr, BasicExpr, proto::or_<BOOST_PP_ENUM_PARAMS(N, G)> >
|
||||
: BOOST_PP_CAT(or_, N)<
|
||||
matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
|
||||
Expr, BasicExpr BOOST_PP_ENUM_TRAILING_PARAMS(N, G)
|
||||
>
|
||||
{};
|
||||
|
||||
// handle proto::and_
|
||||
template<typename Expr, typename BasicExpr, BOOST_PP_ENUM_PARAMS(N, typename G)>
|
||||
struct matches_<Expr, BasicExpr, proto::and_<BOOST_PP_ENUM_PARAMS(N, G)> >
|
||||
: detail::BOOST_PP_CAT(and_, N)<
|
||||
BOOST_PROTO_DEFINE_MATCHES(~, 0, ~)::value,
|
||||
BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFINE_MATCHES, ~)
|
||||
>
|
||||
{};
|
||||
|
||||
#endif
|
||||
|
||||
#if N <= BOOST_PROTO_MAX_ARITY
|
||||
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, N>, proto::basic_expr<Tag, Args2, N> >
|
||||
: BOOST_PP_CAT(and_, N)<
|
||||
BOOST_PROTO_MATCHES_N_FUN(~, 0, ~)::value,
|
||||
BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_MATCHES_N_FUN, ~)
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, N>, proto::basic_expr<proto::_, Args2, N> >
|
||||
: BOOST_PP_CAT(and_, N)<
|
||||
BOOST_PROTO_MATCHES_N_FUN(~, 0, ~)::value,
|
||||
BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_MATCHES_N_FUN, ~)
|
||||
>
|
||||
{};
|
||||
|
||||
#endif
|
||||
|
||||
#undef N
|
||||
|
||||
#endif
|
||||
44
test/external/boost/proto/detail/memfun_funop.hpp
vendored
Normal file
44
test/external/boost/proto/detail/memfun_funop.hpp
vendored
Normal file
@@ -0,0 +1,44 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/memfun_funop.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/memfun_funop.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// memfun_funop.hpp
|
||||
// Contains overloads of memfun::operator().
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/memfun_funop.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
template<BOOST_PP_ENUM_PARAMS(N, typename A)>
|
||||
result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a)) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(BOOST_PP_ENUM_PARAMS(N, a));
|
||||
}
|
||||
|
||||
#undef N
|
||||
|
||||
#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES
|
||||
59
test/external/boost/proto/detail/or_n.hpp
vendored
Normal file
59
test/external/boost/proto/detail/or_n.hpp
vendored
Normal file
@@ -0,0 +1,59 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/or_n.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/or_n.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file or_n.hpp
|
||||
/// Definitions of or_N
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (2, BOOST_PROTO_MAX_LOGICAL_ARITY, <boost/proto/detail/or_n.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#else // BOOST_PP_IS_ITERATING
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
template<bool B, typename Expr, typename BasicExpr, BOOST_PP_ENUM_PARAMS(N, typename G)>
|
||||
struct BOOST_PP_CAT(or_, N)
|
||||
#if 2 == N
|
||||
: mpl::bool_<matches_<Expr, BasicExpr, typename G1::proto_grammar>::value>
|
||||
{
|
||||
typedef G1 which;
|
||||
};
|
||||
#else
|
||||
: BOOST_PP_CAT(or_, BOOST_PP_DEC(N))<
|
||||
matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
|
||||
, Expr, BasicExpr, BOOST_PP_ENUM_SHIFTED_PARAMS(N, G)
|
||||
>
|
||||
{};
|
||||
#endif
|
||||
|
||||
template<typename Expr, typename BasicExpr BOOST_PP_ENUM_TRAILING_PARAMS(N, typename G)>
|
||||
struct BOOST_PP_CAT(or_, N)<true, Expr, BasicExpr, BOOST_PP_ENUM_PARAMS(N, G)>
|
||||
: mpl::true_
|
||||
{
|
||||
typedef G0 which;
|
||||
};
|
||||
|
||||
#undef N
|
||||
|
||||
#endif
|
||||
219
test/external/boost/proto/detail/poly_function.hpp
vendored
Normal file
219
test/external/boost/proto/detail/poly_function.hpp
vendored
Normal file
@@ -0,0 +1,219 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file poly_function.hpp
|
||||
/// A wrapper that makes a tr1-style function object that handles const
|
||||
/// and non-const refs and reference_wrapper arguments, too, and forwards
|
||||
/// the arguments on to the specified implementation.
|
||||
//
|
||||
// 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_DETAIL_POLY_FUNCTION_EAN_2008_05_02
|
||||
#define BOOST_PROTO_DETAIL_POLY_FUNCTION_EAN_2008_05_02
|
||||
|
||||
#include <boost/ref.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/mpl/void.hpp>
|
||||
#include <boost/mpl/size_t.hpp>
|
||||
#include <boost/mpl/eval_if.hpp>
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/facilities/intercept.hpp>
|
||||
#include <boost/preprocessor/iteration/iterate.hpp>
|
||||
#include <boost/preprocessor/repetition/enum.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable: 4181) // const applied to reference type
|
||||
#endif
|
||||
|
||||
namespace boost { namespace proto { namespace detail
|
||||
{
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T>
|
||||
struct normalize_arg
|
||||
{
|
||||
typedef T type;
|
||||
typedef T const &reference;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct normalize_arg<T &>
|
||||
{
|
||||
typedef T type;
|
||||
typedef T const &reference;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct normalize_arg<T const &>
|
||||
{
|
||||
typedef T type;
|
||||
typedef T const &reference;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct normalize_arg<boost::reference_wrapper<T> >
|
||||
{
|
||||
typedef T &type;
|
||||
typedef T &reference;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct normalize_arg<boost::reference_wrapper<T> &>
|
||||
{
|
||||
typedef T &type;
|
||||
typedef T &reference;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct normalize_arg<boost::reference_wrapper<T> const &>
|
||||
{
|
||||
typedef T &type;
|
||||
typedef T &reference;
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T>
|
||||
struct arg
|
||||
{
|
||||
typedef T const &type;
|
||||
|
||||
arg(type t)
|
||||
: value(t)
|
||||
{}
|
||||
|
||||
operator type() const
|
||||
{
|
||||
return this->value;
|
||||
}
|
||||
|
||||
type operator()() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
private:
|
||||
arg &operator =(arg const &);
|
||||
type value;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct arg<T &>
|
||||
{
|
||||
typedef T &type;
|
||||
|
||||
arg(type t)
|
||||
: value(t)
|
||||
{}
|
||||
|
||||
operator type() const
|
||||
{
|
||||
return this->value;
|
||||
}
|
||||
|
||||
type operator()() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
private:
|
||||
arg &operator =(arg const &);
|
||||
type value;
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename T, typename Void = void>
|
||||
struct is_poly_function
|
||||
: mpl::false_
|
||||
{};
|
||||
|
||||
template<typename T>
|
||||
struct is_poly_function<T, typename T::is_poly_function_base_>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
#define BOOST_PROTO_POLY_FUNCTION() \
|
||||
typedef void is_poly_function_base_; \
|
||||
/**/
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
struct poly_function_base
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
BOOST_PROTO_POLY_FUNCTION()
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename Derived, typename NullaryResult = void>
|
||||
struct poly_function
|
||||
: poly_function_base
|
||||
{
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This>
|
||||
struct result<This()>
|
||||
: Derived::template impl<>
|
||||
{
|
||||
typedef typename result::result_type type;
|
||||
};
|
||||
|
||||
NullaryResult operator()() const
|
||||
{
|
||||
result<Derived const()> impl;
|
||||
return impl();
|
||||
}
|
||||
|
||||
#include <boost/proto/detail/poly_function_funop.hpp>
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct wrap_t;
|
||||
|
||||
typedef char poly_function_t;
|
||||
typedef char (&mono_function_t)[2];
|
||||
typedef char (&unknown_function_t)[3];
|
||||
|
||||
template<typename T> poly_function_t test_poly_function(T *, wrap_t<typename T::is_poly_function_base_> * = 0);
|
||||
template<typename T> mono_function_t test_poly_function(T *, wrap_t<typename T::result_type> * = 0);
|
||||
template<typename T> unknown_function_t test_poly_function(T *, ...);
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename Fun, typename Sig, typename Switch = mpl::size_t<sizeof(test_poly_function<Fun>(0,0))> >
|
||||
struct poly_function_traits
|
||||
{
|
||||
typedef typename Fun::template result<Sig>::type result_type;
|
||||
typedef Fun function_type;
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename Fun, typename Sig>
|
||||
struct poly_function_traits<Fun, Sig, mpl::size_t<sizeof(mono_function_t)> >
|
||||
{
|
||||
typedef typename Fun::result_type result_type;
|
||||
typedef Fun function_type;
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename PolyFunSig, bool IsPolyFunction>
|
||||
struct as_mono_function_impl;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename PolyFunSig>
|
||||
struct as_mono_function;
|
||||
|
||||
#include <boost/proto/detail/poly_function_traits.hpp>
|
||||
|
||||
}}} // namespace boost::proto::detail
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
74
test/external/boost/proto/detail/poly_function_funop.hpp
vendored
Normal file
74
test/external/boost/proto/detail/poly_function_funop.hpp
vendored
Normal file
@@ -0,0 +1,74 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/poly_function_funop.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#define BOOST_PROTO_NORMALIZE_ARG(Z, N, DATA) \
|
||||
static_cast<typename normalize_arg<BOOST_PP_CAT(A, N) const &> \
|
||||
::reference>(BOOST_PP_CAT(a, N)) \
|
||||
/**/
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/poly_function_funop.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// poly_function_funop.hpp
|
||||
// Contains overloads of poly_function\<\>::operator()
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/poly_function_funop.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#undef BOOST_PROTO_NORMALIZE_ARG
|
||||
|
||||
#else
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
template<typename This BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
|
||||
struct result<This(BOOST_PP_ENUM_PARAMS(N, A))>
|
||||
: Derived::template impl<
|
||||
BOOST_PP_ENUM_BINARY_PARAMS(
|
||||
N
|
||||
, typename normalize_arg<A
|
||||
, >::type BOOST_PP_INTERCEPT
|
||||
)
|
||||
>
|
||||
{
|
||||
typedef typename result::result_type type;
|
||||
};
|
||||
|
||||
template<BOOST_PP_ENUM_PARAMS(N, typename A)>
|
||||
typename result<
|
||||
Derived const(
|
||||
BOOST_PP_ENUM_BINARY_PARAMS(N, A, const & BOOST_PP_INTERCEPT)
|
||||
)
|
||||
>::type
|
||||
operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a)) const
|
||||
{
|
||||
result<
|
||||
Derived const(
|
||||
BOOST_PP_ENUM_BINARY_PARAMS(N, A, const & BOOST_PP_INTERCEPT)
|
||||
)
|
||||
> impl;
|
||||
|
||||
return impl(BOOST_PP_ENUM(N, BOOST_PROTO_NORMALIZE_ARG, ~));
|
||||
}
|
||||
|
||||
#undef N
|
||||
|
||||
#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES
|
||||
65
test/external/boost/proto/detail/poly_function_traits.hpp
vendored
Normal file
65
test/external/boost/proto/detail/poly_function_traits.hpp
vendored
Normal file
@@ -0,0 +1,65 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/poly_function_traits.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/poly_function_traits.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// poly_function_traits.hpp
|
||||
// Contains specializations of poly_function_traits and as_mono_function
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/poly_function_traits.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename PolyFun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
|
||||
struct poly_function_traits<PolyFun, PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), mpl::size_t<sizeof(poly_function_t)> >
|
||||
{
|
||||
typedef typename PolyFun::template impl<BOOST_PP_ENUM_PARAMS(N, const A)> function_type;
|
||||
typedef typename function_type::result_type result_type;
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename PolyFun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
|
||||
struct as_mono_function_impl<PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), true>
|
||||
{
|
||||
typedef typename PolyFun::template impl<BOOST_PP_ENUM_PARAMS(N, const A)> type;
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename PolyFun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
|
||||
struct as_mono_function_impl<PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), false>
|
||||
{
|
||||
typedef PolyFun type;
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename PolyFun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
|
||||
struct as_mono_function<PolyFun(BOOST_PP_ENUM_PARAMS(N, A))>
|
||||
: as_mono_function_impl<PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), is_poly_function<PolyFun>::value>
|
||||
{};
|
||||
|
||||
#undef N
|
||||
|
||||
#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES
|
||||
43
test/external/boost/proto/detail/pop_front.hpp
vendored
Normal file
43
test/external/boost/proto/detail/pop_front.hpp
vendored
Normal file
@@ -0,0 +1,43 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2006 Joel de Guzman
|
||||
Copyright (c) 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_DETAIL_FUSION_POP_FRONT_EAH_01_22_2008
|
||||
#define BOOST_PROTO_DETAIL_FUSION_POP_FRONT_EAH_01_22_2008
|
||||
|
||||
#include <boost/spirit/fusion/sequence/range.hpp>
|
||||
#include <boost/spirit/fusion/sequence/begin.hpp>
|
||||
#include <boost/spirit/fusion/sequence/end.hpp>
|
||||
#include <boost/spirit/fusion/iterator/next.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
namespace meta
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct pop_front
|
||||
{
|
||||
typedef
|
||||
range<
|
||||
typename next<
|
||||
typename begin<Sequence>::type
|
||||
>::type
|
||||
, typename end<Sequence>::type
|
||||
>
|
||||
type;
|
||||
};
|
||||
}
|
||||
|
||||
template <typename Sequence>
|
||||
inline typename meta::pop_front<Sequence const>::type
|
||||
pop_front(Sequence const& seq)
|
||||
{
|
||||
typedef typename meta::pop_front<Sequence const>::type result;
|
||||
return result(fusion::next(fusion::begin(seq)), fusion::end(seq));
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
310
test/external/boost/proto/detail/preprocessed/and_n.hpp
vendored
Normal file
310
test/external/boost/proto/detail/preprocessed/and_n.hpp
vendored
Normal file
@@ -0,0 +1,310 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file and_n.hpp
|
||||
/// Definitions of and_N, and_impl
|
||||
//
|
||||
// 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)
|
||||
|
||||
|
||||
|
||||
template<bool B, typename P0>
|
||||
struct and_2
|
||||
: mpl::bool_<P0::value>
|
||||
{};
|
||||
template<typename P0>
|
||||
struct and_2<false, P0>
|
||||
: mpl::false_
|
||||
{};
|
||||
template<typename G0 , typename G1, typename Expr, typename State, typename Data>
|
||||
struct _and_impl<proto::and_<G0 , G1>, Expr, State, Data>
|
||||
: proto::transform_impl<Expr, State, Data>
|
||||
{
|
||||
typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1;
|
||||
typedef typename Gimpl1::result_type result_type;
|
||||
result_type operator()(
|
||||
typename _and_impl::expr_param e
|
||||
, typename _and_impl::state_param s
|
||||
, typename _and_impl::data_param d
|
||||
) const
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
Gimpl0()(e,s,d);
|
||||
return Gimpl1()(e,s,d);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
template<bool B, typename P0 , typename P1>
|
||||
struct and_3
|
||||
: and_2<
|
||||
P0::value ,
|
||||
P1
|
||||
>
|
||||
{};
|
||||
template<typename P0 , typename P1>
|
||||
struct and_3<false, P0 , P1>
|
||||
: mpl::false_
|
||||
{};
|
||||
template<typename G0 , typename G1 , typename G2, typename Expr, typename State, typename Data>
|
||||
struct _and_impl<proto::and_<G0 , G1 , G2>, Expr, State, Data>
|
||||
: proto::transform_impl<Expr, State, Data>
|
||||
{
|
||||
typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2;
|
||||
typedef typename Gimpl2::result_type result_type;
|
||||
result_type operator()(
|
||||
typename _and_impl::expr_param e
|
||||
, typename _and_impl::state_param s
|
||||
, typename _and_impl::data_param d
|
||||
) const
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
Gimpl0()(e,s,d); Gimpl1()(e,s,d);
|
||||
return Gimpl2()(e,s,d);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
template<bool B, typename P0 , typename P1 , typename P2>
|
||||
struct and_4
|
||||
: and_3<
|
||||
P0::value ,
|
||||
P1 , P2
|
||||
>
|
||||
{};
|
||||
template<typename P0 , typename P1 , typename P2>
|
||||
struct and_4<false, P0 , P1 , P2>
|
||||
: mpl::false_
|
||||
{};
|
||||
template<typename G0 , typename G1 , typename G2 , typename G3, typename Expr, typename State, typename Data>
|
||||
struct _and_impl<proto::and_<G0 , G1 , G2 , G3>, Expr, State, Data>
|
||||
: proto::transform_impl<Expr, State, Data>
|
||||
{
|
||||
typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3;
|
||||
typedef typename Gimpl3::result_type result_type;
|
||||
result_type operator()(
|
||||
typename _and_impl::expr_param e
|
||||
, typename _and_impl::state_param s
|
||||
, typename _and_impl::data_param d
|
||||
) const
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d);
|
||||
return Gimpl3()(e,s,d);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
template<bool B, typename P0 , typename P1 , typename P2 , typename P3>
|
||||
struct and_5
|
||||
: and_4<
|
||||
P0::value ,
|
||||
P1 , P2 , P3
|
||||
>
|
||||
{};
|
||||
template<typename P0 , typename P1 , typename P2 , typename P3>
|
||||
struct and_5<false, P0 , P1 , P2 , P3>
|
||||
: mpl::false_
|
||||
{};
|
||||
template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4, typename Expr, typename State, typename Data>
|
||||
struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4>, Expr, State, Data>
|
||||
: proto::transform_impl<Expr, State, Data>
|
||||
{
|
||||
typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4;
|
||||
typedef typename Gimpl4::result_type result_type;
|
||||
result_type operator()(
|
||||
typename _and_impl::expr_param e
|
||||
, typename _and_impl::state_param s
|
||||
, typename _and_impl::data_param d
|
||||
) const
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d);
|
||||
return Gimpl4()(e,s,d);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4>
|
||||
struct and_6
|
||||
: and_5<
|
||||
P0::value ,
|
||||
P1 , P2 , P3 , P4
|
||||
>
|
||||
{};
|
||||
template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4>
|
||||
struct and_6<false, P0 , P1 , P2 , P3 , P4>
|
||||
: mpl::false_
|
||||
{};
|
||||
template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5, typename Expr, typename State, typename Data>
|
||||
struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5>, Expr, State, Data>
|
||||
: proto::transform_impl<Expr, State, Data>
|
||||
{
|
||||
typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5;
|
||||
typedef typename Gimpl5::result_type result_type;
|
||||
result_type operator()(
|
||||
typename _and_impl::expr_param e
|
||||
, typename _and_impl::state_param s
|
||||
, typename _and_impl::data_param d
|
||||
) const
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d);
|
||||
return Gimpl5()(e,s,d);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5>
|
||||
struct and_7
|
||||
: and_6<
|
||||
P0::value ,
|
||||
P1 , P2 , P3 , P4 , P5
|
||||
>
|
||||
{};
|
||||
template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5>
|
||||
struct and_7<false, P0 , P1 , P2 , P3 , P4 , P5>
|
||||
: mpl::false_
|
||||
{};
|
||||
template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6, typename Expr, typename State, typename Data>
|
||||
struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6>, Expr, State, Data>
|
||||
: proto::transform_impl<Expr, State, Data>
|
||||
{
|
||||
typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6;
|
||||
typedef typename Gimpl6::result_type result_type;
|
||||
result_type operator()(
|
||||
typename _and_impl::expr_param e
|
||||
, typename _and_impl::state_param s
|
||||
, typename _and_impl::data_param d
|
||||
) const
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d);
|
||||
return Gimpl6()(e,s,d);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6>
|
||||
struct and_8
|
||||
: and_7<
|
||||
P0::value ,
|
||||
P1 , P2 , P3 , P4 , P5 , P6
|
||||
>
|
||||
{};
|
||||
template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6>
|
||||
struct and_8<false, P0 , P1 , P2 , P3 , P4 , P5 , P6>
|
||||
: mpl::false_
|
||||
{};
|
||||
template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7, typename Expr, typename State, typename Data>
|
||||
struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7>, Expr, State, Data>
|
||||
: proto::transform_impl<Expr, State, Data>
|
||||
{
|
||||
typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7;
|
||||
typedef typename Gimpl7::result_type result_type;
|
||||
result_type operator()(
|
||||
typename _and_impl::expr_param e
|
||||
, typename _and_impl::state_param s
|
||||
, typename _and_impl::data_param d
|
||||
) const
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d);
|
||||
return Gimpl7()(e,s,d);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7>
|
||||
struct and_9
|
||||
: and_8<
|
||||
P0::value ,
|
||||
P1 , P2 , P3 , P4 , P5 , P6 , P7
|
||||
>
|
||||
{};
|
||||
template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7>
|
||||
struct and_9<false, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7>
|
||||
: mpl::false_
|
||||
{};
|
||||
template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8, typename Expr, typename State, typename Data>
|
||||
struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8>, Expr, State, Data>
|
||||
: proto::transform_impl<Expr, State, Data>
|
||||
{
|
||||
typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7; typedef typename proto::when<proto::_, G8> ::template impl<Expr, State, Data> Gimpl8;
|
||||
typedef typename Gimpl8::result_type result_type;
|
||||
result_type operator()(
|
||||
typename _and_impl::expr_param e
|
||||
, typename _and_impl::state_param s
|
||||
, typename _and_impl::data_param d
|
||||
) const
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d); Gimpl7()(e,s,d);
|
||||
return Gimpl8()(e,s,d);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8>
|
||||
struct and_10
|
||||
: and_9<
|
||||
P0::value ,
|
||||
P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8
|
||||
>
|
||||
{};
|
||||
template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8>
|
||||
struct and_10<false, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8>
|
||||
: mpl::false_
|
||||
{};
|
||||
template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9, typename Expr, typename State, typename Data>
|
||||
struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9>, Expr, State, Data>
|
||||
: proto::transform_impl<Expr, State, Data>
|
||||
{
|
||||
typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7; typedef typename proto::when<proto::_, G8> ::template impl<Expr, State, Data> Gimpl8; typedef typename proto::when<proto::_, G9> ::template impl<Expr, State, Data> Gimpl9;
|
||||
typedef typename Gimpl9::result_type result_type;
|
||||
result_type operator()(
|
||||
typename _and_impl::expr_param e
|
||||
, typename _and_impl::state_param s
|
||||
, typename _and_impl::data_param d
|
||||
) const
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d); Gimpl7()(e,s,d); Gimpl8()(e,s,d);
|
||||
return Gimpl9()(e,s,d);
|
||||
}
|
||||
};
|
||||
162
test/external/boost/proto/detail/preprocessed/args.hpp
vendored
Normal file
162
test/external/boost/proto/detail/preprocessed/args.hpp
vendored
Normal file
@@ -0,0 +1,162 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file args.hpp
|
||||
/// Contains definition of \c term\<\>, \c list1\<\>, \c list2\<\>, ...
|
||||
/// class templates.
|
||||
//
|
||||
// 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)
|
||||
|
||||
|
||||
|
||||
|
||||
template< typename Arg0 >
|
||||
struct term
|
||||
{
|
||||
static const long arity = 0;
|
||||
typedef Arg0 child0;
|
||||
typedef mpl::void_ child1; typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
|
||||
|
||||
|
||||
typedef Arg0 back_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
template< typename Arg0 >
|
||||
struct list1
|
||||
{
|
||||
static const long arity = 1;
|
||||
typedef Arg0 child0;
|
||||
typedef mpl::void_ child1; typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
|
||||
|
||||
|
||||
typedef Arg0 back_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
template< typename Arg0 , typename Arg1 >
|
||||
struct list2
|
||||
{
|
||||
static const long arity = 2;
|
||||
typedef Arg0 child0; typedef Arg1 child1;
|
||||
typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
|
||||
|
||||
|
||||
typedef Arg1 back_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
template< typename Arg0 , typename Arg1 , typename Arg2 >
|
||||
struct list3
|
||||
{
|
||||
static const long arity = 3;
|
||||
typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2;
|
||||
typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
|
||||
|
||||
|
||||
typedef Arg2 back_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 >
|
||||
struct list4
|
||||
{
|
||||
static const long arity = 4;
|
||||
typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3;
|
||||
typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
|
||||
|
||||
|
||||
typedef Arg3 back_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >
|
||||
struct list5
|
||||
{
|
||||
static const long arity = 5;
|
||||
typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4;
|
||||
typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
|
||||
|
||||
|
||||
typedef Arg4 back_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >
|
||||
struct list6
|
||||
{
|
||||
static const long arity = 6;
|
||||
typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5;
|
||||
typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
|
||||
|
||||
|
||||
typedef Arg5 back_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 >
|
||||
struct list7
|
||||
{
|
||||
static const long arity = 7;
|
||||
typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6;
|
||||
typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
|
||||
|
||||
|
||||
typedef Arg6 back_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 >
|
||||
struct list8
|
||||
{
|
||||
static const long arity = 8;
|
||||
typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef Arg7 child7;
|
||||
typedef mpl::void_ child8; typedef mpl::void_ child9;
|
||||
|
||||
|
||||
typedef Arg7 back_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 >
|
||||
struct list9
|
||||
{
|
||||
static const long arity = 9;
|
||||
typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef Arg7 child7; typedef Arg8 child8;
|
||||
typedef mpl::void_ child9;
|
||||
|
||||
|
||||
typedef Arg8 back_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 >
|
||||
struct list10
|
||||
{
|
||||
static const long arity = 10;
|
||||
typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef Arg7 child7; typedef Arg8 child8; typedef Arg9 child9;
|
||||
|
||||
|
||||
|
||||
typedef Arg9 back_;
|
||||
};
|
||||
774
test/external/boost/proto/detail/preprocessed/basic_expr.hpp
vendored
Normal file
774
test/external/boost/proto/detail/preprocessed/basic_expr.hpp
vendored
Normal file
@@ -0,0 +1,774 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file basic_expr.hpp
|
||||
/// Contains definition of basic_expr\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Tag, typename Arg0>
|
||||
struct basic_expr<Tag, term<Arg0>, 0>
|
||||
{
|
||||
typedef Tag proto_tag;
|
||||
static const long proto_arity_c = 0;
|
||||
typedef mpl::long_<0 > proto_arity;
|
||||
typedef basic_expr proto_base_expr;
|
||||
typedef term<Arg0> proto_args;
|
||||
typedef basic_expr proto_grammar;
|
||||
typedef basic_default_domain proto_domain;
|
||||
typedef default_generator proto_generator;
|
||||
typedef proto::tag::proto_expr fusion_tag;
|
||||
typedef basic_expr proto_derived_expr;
|
||||
typedef void proto_is_expr_;
|
||||
typedef Arg0 proto_child0; proto_child0 child0;
|
||||
typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
|
||||
|
||||
|
||||
basic_expr const &proto_base() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
basic_expr &proto_base()
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<typename A0>
|
||||
static basic_expr const make(A0 &a0)
|
||||
{
|
||||
return detail::make_terminal(a0, static_cast<basic_expr *>(0), static_cast<proto_args *>(0));
|
||||
}
|
||||
|
||||
|
||||
template<typename A0>
|
||||
static basic_expr const make(A0 const &a0)
|
||||
{
|
||||
return detail::make_terminal(a0, static_cast<basic_expr *>(0), static_cast<proto_args *>(0));
|
||||
}
|
||||
|
||||
|
||||
typedef detail::not_a_valid_type address_of_hack_type_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Tag , typename Arg0>
|
||||
struct basic_expr<Tag, list1<Arg0>, 1 >
|
||||
{
|
||||
typedef Tag proto_tag;
|
||||
static const long proto_arity_c = 1;
|
||||
typedef mpl::long_<1 > proto_arity;
|
||||
typedef basic_expr proto_base_expr;
|
||||
typedef list1<Arg0> proto_args;
|
||||
typedef basic_expr proto_grammar;
|
||||
typedef basic_default_domain proto_domain;
|
||||
typedef default_generator proto_generator;
|
||||
typedef proto::tag::proto_expr fusion_tag;
|
||||
typedef basic_expr proto_derived_expr;
|
||||
typedef void proto_is_expr_;
|
||||
typedef Arg0 proto_child0; proto_child0 child0;
|
||||
typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
|
||||
|
||||
|
||||
basic_expr const &proto_base() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
basic_expr &proto_base()
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<typename A0>
|
||||
static basic_expr const make(A0 const &a0)
|
||||
{
|
||||
basic_expr that = {a0};
|
||||
return that;
|
||||
}
|
||||
|
||||
|
||||
|
||||
typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
operator address_of_hack_type_() const
|
||||
{
|
||||
return boost::addressof(this->child0);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Tag , typename Arg0 , typename Arg1>
|
||||
struct basic_expr<Tag, list2<Arg0 , Arg1>, 2 >
|
||||
{
|
||||
typedef Tag proto_tag;
|
||||
static const long proto_arity_c = 2;
|
||||
typedef mpl::long_<2 > proto_arity;
|
||||
typedef basic_expr proto_base_expr;
|
||||
typedef list2<Arg0 , Arg1> proto_args;
|
||||
typedef basic_expr proto_grammar;
|
||||
typedef basic_default_domain proto_domain;
|
||||
typedef default_generator proto_generator;
|
||||
typedef proto::tag::proto_expr fusion_tag;
|
||||
typedef basic_expr proto_derived_expr;
|
||||
typedef void proto_is_expr_;
|
||||
typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1;
|
||||
typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
|
||||
|
||||
|
||||
basic_expr const &proto_base() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
basic_expr &proto_base()
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<typename A0 , typename A1>
|
||||
static basic_expr const make(A0 const &a0 , A1 const &a1)
|
||||
{
|
||||
basic_expr that = {a0 , a1};
|
||||
return that;
|
||||
}
|
||||
|
||||
|
||||
typedef detail::not_a_valid_type address_of_hack_type_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2>
|
||||
struct basic_expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3 >
|
||||
{
|
||||
typedef Tag proto_tag;
|
||||
static const long proto_arity_c = 3;
|
||||
typedef mpl::long_<3 > proto_arity;
|
||||
typedef basic_expr proto_base_expr;
|
||||
typedef list3<Arg0 , Arg1 , Arg2> proto_args;
|
||||
typedef basic_expr proto_grammar;
|
||||
typedef basic_default_domain proto_domain;
|
||||
typedef default_generator proto_generator;
|
||||
typedef proto::tag::proto_expr fusion_tag;
|
||||
typedef basic_expr proto_derived_expr;
|
||||
typedef void proto_is_expr_;
|
||||
typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2;
|
||||
typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
|
||||
|
||||
|
||||
basic_expr const &proto_base() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
basic_expr &proto_base()
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<typename A0 , typename A1 , typename A2>
|
||||
static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2)
|
||||
{
|
||||
basic_expr that = {a0 , a1 , a2};
|
||||
return that;
|
||||
}
|
||||
|
||||
|
||||
typedef detail::not_a_valid_type address_of_hack_type_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3>
|
||||
struct basic_expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4 >
|
||||
{
|
||||
typedef Tag proto_tag;
|
||||
static const long proto_arity_c = 4;
|
||||
typedef mpl::long_<4 > proto_arity;
|
||||
typedef basic_expr proto_base_expr;
|
||||
typedef list4<Arg0 , Arg1 , Arg2 , Arg3> proto_args;
|
||||
typedef basic_expr proto_grammar;
|
||||
typedef basic_default_domain proto_domain;
|
||||
typedef default_generator proto_generator;
|
||||
typedef proto::tag::proto_expr fusion_tag;
|
||||
typedef basic_expr proto_derived_expr;
|
||||
typedef void proto_is_expr_;
|
||||
typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3;
|
||||
typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
|
||||
|
||||
|
||||
basic_expr const &proto_base() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
basic_expr &proto_base()
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3>
|
||||
static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3)
|
||||
{
|
||||
basic_expr that = {a0 , a1 , a2 , a3};
|
||||
return that;
|
||||
}
|
||||
|
||||
|
||||
typedef detail::not_a_valid_type address_of_hack_type_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4>
|
||||
struct basic_expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5 >
|
||||
{
|
||||
typedef Tag proto_tag;
|
||||
static const long proto_arity_c = 5;
|
||||
typedef mpl::long_<5 > proto_arity;
|
||||
typedef basic_expr proto_base_expr;
|
||||
typedef list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4> proto_args;
|
||||
typedef basic_expr proto_grammar;
|
||||
typedef basic_default_domain proto_domain;
|
||||
typedef default_generator proto_generator;
|
||||
typedef proto::tag::proto_expr fusion_tag;
|
||||
typedef basic_expr proto_derived_expr;
|
||||
typedef void proto_is_expr_;
|
||||
typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4;
|
||||
typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
|
||||
|
||||
|
||||
basic_expr const &proto_base() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
basic_expr &proto_base()
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4)
|
||||
{
|
||||
basic_expr that = {a0 , a1 , a2 , a3 , a4};
|
||||
return that;
|
||||
}
|
||||
|
||||
|
||||
typedef detail::not_a_valid_type address_of_hack_type_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5>
|
||||
struct basic_expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6 >
|
||||
{
|
||||
typedef Tag proto_tag;
|
||||
static const long proto_arity_c = 6;
|
||||
typedef mpl::long_<6 > proto_arity;
|
||||
typedef basic_expr proto_base_expr;
|
||||
typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> proto_args;
|
||||
typedef basic_expr proto_grammar;
|
||||
typedef basic_default_domain proto_domain;
|
||||
typedef default_generator proto_generator;
|
||||
typedef proto::tag::proto_expr fusion_tag;
|
||||
typedef basic_expr proto_derived_expr;
|
||||
typedef void proto_is_expr_;
|
||||
typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5;
|
||||
typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
|
||||
|
||||
|
||||
basic_expr const &proto_base() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
basic_expr &proto_base()
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5)
|
||||
{
|
||||
basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5};
|
||||
return that;
|
||||
}
|
||||
|
||||
|
||||
typedef detail::not_a_valid_type address_of_hack_type_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6>
|
||||
struct basic_expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7 >
|
||||
{
|
||||
typedef Tag proto_tag;
|
||||
static const long proto_arity_c = 7;
|
||||
typedef mpl::long_<7 > proto_arity;
|
||||
typedef basic_expr proto_base_expr;
|
||||
typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> proto_args;
|
||||
typedef basic_expr proto_grammar;
|
||||
typedef basic_default_domain proto_domain;
|
||||
typedef default_generator proto_generator;
|
||||
typedef proto::tag::proto_expr fusion_tag;
|
||||
typedef basic_expr proto_derived_expr;
|
||||
typedef void proto_is_expr_;
|
||||
typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6;
|
||||
typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
|
||||
|
||||
|
||||
basic_expr const &proto_base() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
basic_expr &proto_base()
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6)
|
||||
{
|
||||
basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6};
|
||||
return that;
|
||||
}
|
||||
|
||||
|
||||
typedef detail::not_a_valid_type address_of_hack_type_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7>
|
||||
struct basic_expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8 >
|
||||
{
|
||||
typedef Tag proto_tag;
|
||||
static const long proto_arity_c = 8;
|
||||
typedef mpl::long_<8 > proto_arity;
|
||||
typedef basic_expr proto_base_expr;
|
||||
typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> proto_args;
|
||||
typedef basic_expr proto_grammar;
|
||||
typedef basic_default_domain proto_domain;
|
||||
typedef default_generator proto_generator;
|
||||
typedef proto::tag::proto_expr fusion_tag;
|
||||
typedef basic_expr proto_derived_expr;
|
||||
typedef void proto_is_expr_;
|
||||
typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7;
|
||||
typedef void proto_child8; typedef void proto_child9;
|
||||
|
||||
|
||||
basic_expr const &proto_base() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
basic_expr &proto_base()
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7)
|
||||
{
|
||||
basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7};
|
||||
return that;
|
||||
}
|
||||
|
||||
|
||||
typedef detail::not_a_valid_type address_of_hack_type_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8>
|
||||
struct basic_expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9 >
|
||||
{
|
||||
typedef Tag proto_tag;
|
||||
static const long proto_arity_c = 9;
|
||||
typedef mpl::long_<9 > proto_arity;
|
||||
typedef basic_expr proto_base_expr;
|
||||
typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> proto_args;
|
||||
typedef basic_expr proto_grammar;
|
||||
typedef basic_default_domain proto_domain;
|
||||
typedef default_generator proto_generator;
|
||||
typedef proto::tag::proto_expr fusion_tag;
|
||||
typedef basic_expr proto_derived_expr;
|
||||
typedef void proto_is_expr_;
|
||||
typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8;
|
||||
typedef void proto_child9;
|
||||
|
||||
|
||||
basic_expr const &proto_base() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
basic_expr &proto_base()
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8)
|
||||
{
|
||||
basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8};
|
||||
return that;
|
||||
}
|
||||
|
||||
|
||||
typedef detail::not_a_valid_type address_of_hack_type_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9>
|
||||
struct basic_expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10 >
|
||||
{
|
||||
typedef Tag proto_tag;
|
||||
static const long proto_arity_c = 10;
|
||||
typedef mpl::long_<10 > proto_arity;
|
||||
typedef basic_expr proto_base_expr;
|
||||
typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> proto_args;
|
||||
typedef basic_expr proto_grammar;
|
||||
typedef basic_default_domain proto_domain;
|
||||
typedef default_generator proto_generator;
|
||||
typedef proto::tag::proto_expr fusion_tag;
|
||||
typedef basic_expr proto_derived_expr;
|
||||
typedef void proto_is_expr_;
|
||||
typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef Arg9 proto_child9; proto_child9 child9;
|
||||
|
||||
|
||||
|
||||
basic_expr const &proto_base() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
basic_expr &proto_base()
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9)
|
||||
{
|
||||
basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9};
|
||||
return that;
|
||||
}
|
||||
|
||||
|
||||
typedef detail::not_a_valid_type address_of_hack_type_;
|
||||
};
|
||||
117
test/external/boost/proto/detail/preprocessed/classtypeof.hpp
vendored
Normal file
117
test/external/boost/proto/detail/preprocessed/classtypeof.hpp
vendored
Normal file
@@ -0,0 +1,117 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// classtypeof.hpp
|
||||
// Contains specializations of the classtypeof\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
template<typename T, typename U >
|
||||
struct classtypeof<T (U::*)()>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U >
|
||||
struct classtypeof<T (U::*)() const>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0>
|
||||
struct classtypeof<T (U::*)(A0)>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0>
|
||||
struct classtypeof<T (U::*)(A0) const>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0 , typename A1>
|
||||
struct classtypeof<T (U::*)(A0 , A1)>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0 , typename A1>
|
||||
struct classtypeof<T (U::*)(A0 , A1) const>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0 , typename A1 , typename A2>
|
||||
struct classtypeof<T (U::*)(A0 , A1 , A2)>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0 , typename A1 , typename A2>
|
||||
struct classtypeof<T (U::*)(A0 , A1 , A2) const>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3>
|
||||
struct classtypeof<T (U::*)(A0 , A1 , A2 , A3)>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3>
|
||||
struct classtypeof<T (U::*)(A0 , A1 , A2 , A3) const>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4)>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4) const>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5)>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5) const>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6) const>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7) const>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8) const>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9) const>
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
119
test/external/boost/proto/detail/preprocessed/deduce_domain_n.hpp
vendored
Normal file
119
test/external/boost/proto/detail/preprocessed/deduce_domain_n.hpp
vendored
Normal file
@@ -0,0 +1,119 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// deduce_domain_n.hpp
|
||||
// Definitions of common_domain[n] and deduce_domain[n] class templates.
|
||||
//
|
||||
// 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)
|
||||
template<typename A0 , typename A1 , typename A2>
|
||||
struct common_domain3
|
||||
{
|
||||
typedef A0 common1;
|
||||
typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3;
|
||||
typedef common3 type;
|
||||
BOOST_PROTO_ASSERT_VALID_DOMAIN(type);
|
||||
};
|
||||
template<typename E0 , typename E1 , typename E2>
|
||||
struct deduce_domain3
|
||||
: common_domain3<
|
||||
typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type
|
||||
>
|
||||
{};
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3>
|
||||
struct common_domain4
|
||||
{
|
||||
typedef A0 common1;
|
||||
typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4;
|
||||
typedef common4 type;
|
||||
BOOST_PROTO_ASSERT_VALID_DOMAIN(type);
|
||||
};
|
||||
template<typename E0 , typename E1 , typename E2 , typename E3>
|
||||
struct deduce_domain4
|
||||
: common_domain4<
|
||||
typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type
|
||||
>
|
||||
{};
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
struct common_domain5
|
||||
{
|
||||
typedef A0 common1;
|
||||
typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5;
|
||||
typedef common5 type;
|
||||
BOOST_PROTO_ASSERT_VALID_DOMAIN(type);
|
||||
};
|
||||
template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4>
|
||||
struct deduce_domain5
|
||||
: common_domain5<
|
||||
typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type
|
||||
>
|
||||
{};
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
struct common_domain6
|
||||
{
|
||||
typedef A0 common1;
|
||||
typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6;
|
||||
typedef common6 type;
|
||||
BOOST_PROTO_ASSERT_VALID_DOMAIN(type);
|
||||
};
|
||||
template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5>
|
||||
struct deduce_domain6
|
||||
: common_domain6<
|
||||
typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type
|
||||
>
|
||||
{};
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
struct common_domain7
|
||||
{
|
||||
typedef A0 common1;
|
||||
typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7;
|
||||
typedef common7 type;
|
||||
BOOST_PROTO_ASSERT_VALID_DOMAIN(type);
|
||||
};
|
||||
template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6>
|
||||
struct deduce_domain7
|
||||
: common_domain7<
|
||||
typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type
|
||||
>
|
||||
{};
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
struct common_domain8
|
||||
{
|
||||
typedef A0 common1;
|
||||
typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7; typedef typename common_domain2<common7, A7>::type common8;
|
||||
typedef common8 type;
|
||||
BOOST_PROTO_ASSERT_VALID_DOMAIN(type);
|
||||
};
|
||||
template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6 , typename E7>
|
||||
struct deduce_domain8
|
||||
: common_domain8<
|
||||
typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type , typename domain_of<E7 >::type
|
||||
>
|
||||
{};
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
struct common_domain9
|
||||
{
|
||||
typedef A0 common1;
|
||||
typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7; typedef typename common_domain2<common7, A7>::type common8; typedef typename common_domain2<common8, A8>::type common9;
|
||||
typedef common9 type;
|
||||
BOOST_PROTO_ASSERT_VALID_DOMAIN(type);
|
||||
};
|
||||
template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6 , typename E7 , typename E8>
|
||||
struct deduce_domain9
|
||||
: common_domain9<
|
||||
typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type , typename domain_of<E7 >::type , typename domain_of<E8 >::type
|
||||
>
|
||||
{};
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
struct common_domain10
|
||||
{
|
||||
typedef A0 common1;
|
||||
typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7; typedef typename common_domain2<common7, A7>::type common8; typedef typename common_domain2<common8, A8>::type common9; typedef typename common_domain2<common9, A9>::type common10;
|
||||
typedef common10 type;
|
||||
BOOST_PROTO_ASSERT_VALID_DOMAIN(type);
|
||||
};
|
||||
template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6 , typename E7 , typename E8 , typename E9>
|
||||
struct deduce_domain10
|
||||
: common_domain10<
|
||||
typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type , typename domain_of<E7 >::type , typename domain_of<E8 >::type , typename domain_of<E9 >::type
|
||||
>
|
||||
{};
|
||||
237
test/external/boost/proto/detail/preprocessed/deep_copy.hpp
vendored
Normal file
237
test/external/boost/proto/detail/preprocessed/deep_copy.hpp
vendored
Normal file
@@ -0,0 +1,237 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file deep_copy.hpp
|
||||
/// Replace all nodes stored by reference by nodes stored by value.
|
||||
//
|
||||
// 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)
|
||||
template<typename Expr>
|
||||
struct deep_copy_impl<Expr, 1>
|
||||
{
|
||||
typedef
|
||||
typename base_expr<
|
||||
typename Expr::proto_domain
|
||||
, typename Expr::proto_tag
|
||||
, list1<
|
||||
typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type
|
||||
>
|
||||
>::type
|
||||
expr_type;
|
||||
typedef typename Expr::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
template<typename Expr2, typename S, typename D>
|
||||
result_type operator()(Expr2 const &e, S const &, D const &) const
|
||||
{
|
||||
expr_type const that = {
|
||||
proto::deep_copy(e.proto_base().child0)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Expr>
|
||||
struct deep_copy_impl<Expr, 2>
|
||||
{
|
||||
typedef
|
||||
typename base_expr<
|
||||
typename Expr::proto_domain
|
||||
, typename Expr::proto_tag
|
||||
, list2<
|
||||
typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type
|
||||
>
|
||||
>::type
|
||||
expr_type;
|
||||
typedef typename Expr::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
template<typename Expr2, typename S, typename D>
|
||||
result_type operator()(Expr2 const &e, S const &, D const &) const
|
||||
{
|
||||
expr_type const that = {
|
||||
proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Expr>
|
||||
struct deep_copy_impl<Expr, 3>
|
||||
{
|
||||
typedef
|
||||
typename base_expr<
|
||||
typename Expr::proto_domain
|
||||
, typename Expr::proto_tag
|
||||
, list3<
|
||||
typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type
|
||||
>
|
||||
>::type
|
||||
expr_type;
|
||||
typedef typename Expr::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
template<typename Expr2, typename S, typename D>
|
||||
result_type operator()(Expr2 const &e, S const &, D const &) const
|
||||
{
|
||||
expr_type const that = {
|
||||
proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Expr>
|
||||
struct deep_copy_impl<Expr, 4>
|
||||
{
|
||||
typedef
|
||||
typename base_expr<
|
||||
typename Expr::proto_domain
|
||||
, typename Expr::proto_tag
|
||||
, list4<
|
||||
typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type
|
||||
>
|
||||
>::type
|
||||
expr_type;
|
||||
typedef typename Expr::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
template<typename Expr2, typename S, typename D>
|
||||
result_type operator()(Expr2 const &e, S const &, D const &) const
|
||||
{
|
||||
expr_type const that = {
|
||||
proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Expr>
|
||||
struct deep_copy_impl<Expr, 5>
|
||||
{
|
||||
typedef
|
||||
typename base_expr<
|
||||
typename Expr::proto_domain
|
||||
, typename Expr::proto_tag
|
||||
, list5<
|
||||
typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type
|
||||
>
|
||||
>::type
|
||||
expr_type;
|
||||
typedef typename Expr::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
template<typename Expr2, typename S, typename D>
|
||||
result_type operator()(Expr2 const &e, S const &, D const &) const
|
||||
{
|
||||
expr_type const that = {
|
||||
proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Expr>
|
||||
struct deep_copy_impl<Expr, 6>
|
||||
{
|
||||
typedef
|
||||
typename base_expr<
|
||||
typename Expr::proto_domain
|
||||
, typename Expr::proto_tag
|
||||
, list6<
|
||||
typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type
|
||||
>
|
||||
>::type
|
||||
expr_type;
|
||||
typedef typename Expr::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
template<typename Expr2, typename S, typename D>
|
||||
result_type operator()(Expr2 const &e, S const &, D const &) const
|
||||
{
|
||||
expr_type const that = {
|
||||
proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Expr>
|
||||
struct deep_copy_impl<Expr, 7>
|
||||
{
|
||||
typedef
|
||||
typename base_expr<
|
||||
typename Expr::proto_domain
|
||||
, typename Expr::proto_tag
|
||||
, list7<
|
||||
typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type
|
||||
>
|
||||
>::type
|
||||
expr_type;
|
||||
typedef typename Expr::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
template<typename Expr2, typename S, typename D>
|
||||
result_type operator()(Expr2 const &e, S const &, D const &) const
|
||||
{
|
||||
expr_type const that = {
|
||||
proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Expr>
|
||||
struct deep_copy_impl<Expr, 8>
|
||||
{
|
||||
typedef
|
||||
typename base_expr<
|
||||
typename Expr::proto_domain
|
||||
, typename Expr::proto_tag
|
||||
, list8<
|
||||
typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child7 >::type::proto_derived_expr >::result_type
|
||||
>
|
||||
>::type
|
||||
expr_type;
|
||||
typedef typename Expr::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
template<typename Expr2, typename S, typename D>
|
||||
result_type operator()(Expr2 const &e, S const &, D const &) const
|
||||
{
|
||||
expr_type const that = {
|
||||
proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) , proto::deep_copy(e.proto_base().child7)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Expr>
|
||||
struct deep_copy_impl<Expr, 9>
|
||||
{
|
||||
typedef
|
||||
typename base_expr<
|
||||
typename Expr::proto_domain
|
||||
, typename Expr::proto_tag
|
||||
, list9<
|
||||
typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child7 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child8 >::type::proto_derived_expr >::result_type
|
||||
>
|
||||
>::type
|
||||
expr_type;
|
||||
typedef typename Expr::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
template<typename Expr2, typename S, typename D>
|
||||
result_type operator()(Expr2 const &e, S const &, D const &) const
|
||||
{
|
||||
expr_type const that = {
|
||||
proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) , proto::deep_copy(e.proto_base().child7) , proto::deep_copy(e.proto_base().child8)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Expr>
|
||||
struct deep_copy_impl<Expr, 10>
|
||||
{
|
||||
typedef
|
||||
typename base_expr<
|
||||
typename Expr::proto_domain
|
||||
, typename Expr::proto_tag
|
||||
, list10<
|
||||
typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child7 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child8 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child9 >::type::proto_derived_expr >::result_type
|
||||
>
|
||||
>::type
|
||||
expr_type;
|
||||
typedef typename Expr::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
template<typename Expr2, typename S, typename D>
|
||||
result_type operator()(Expr2 const &e, S const &, D const &) const
|
||||
{
|
||||
expr_type const that = {
|
||||
proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) , proto::deep_copy(e.proto_base().child7) , proto::deep_copy(e.proto_base().child8) , proto::deep_copy(e.proto_base().child9)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
3528
test/external/boost/proto/detail/preprocessed/expr.hpp
vendored
Normal file
3528
test/external/boost/proto/detail/preprocessed/expr.hpp
vendored
Normal file
File diff suppressed because it is too large
Load Diff
2102
test/external/boost/proto/detail/preprocessed/expr_variadic.hpp
vendored
Normal file
2102
test/external/boost/proto/detail/preprocessed/expr_variadic.hpp
vendored
Normal file
File diff suppressed because it is too large
Load Diff
18
test/external/boost/proto/detail/preprocessed/extends_funop.hpp
vendored
Normal file
18
test/external/boost/proto/detail/preprocessed/extends_funop.hpp
vendored
Normal file
@@ -0,0 +1,18 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file extends_funop.hpp
|
||||
/// Definitions for extends\<\>::operator()
|
||||
//
|
||||
// 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)
|
||||
template<typename Sig> struct result { typedef typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop< Sig , proto_derived_expr , proto_domain >::type ) >::type const type; };
|
||||
typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop0< proto_derived_expr const , proto_domain >::type ) >::type const operator ()() const { typedef boost::proto::result_of::funop0< proto_derived_expr const , proto_domain > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) ) ); } typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop0< proto_derived_expr , proto_domain >::type ) >::type const operator ()() { typedef boost::proto::result_of::funop0< proto_derived_expr , proto_domain > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) ) ); }
|
||||
template<typename A0> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 >::type ) >::type const operator ()(A0 const &a0) const { typedef boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 ) ); } template<typename A0> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop1< proto_derived_expr , proto_domain , const A0 >::type ) >::type const operator ()(A0 const &a0) { typedef boost::proto::result_of::funop1< proto_derived_expr , proto_domain , const A0 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 ) ); }
|
||||
template<typename A0 , typename A1> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) const { typedef boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 ) ); } template<typename A0 , typename A1> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) { typedef boost::proto::result_of::funop2< proto_derived_expr , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 ) ); }
|
||||
template<typename A0 , typename A1 , typename A2> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { typedef boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 ) ); } template<typename A0 , typename A1 , typename A2> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) { typedef boost::proto::result_of::funop3< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 ) ); }
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { typedef boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) { typedef boost::proto::result_of::funop4< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 ) ); }
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { typedef boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) { typedef boost::proto::result_of::funop5< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 ) ); }
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { typedef boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) { typedef boost::proto::result_of::funop6< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); }
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { typedef boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) { typedef boost::proto::result_of::funop7< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 ) ); }
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { typedef boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) { typedef boost::proto::result_of::funop8< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ) ); }
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { typedef boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) { typedef boost::proto::result_of::funop9< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); }
|
||||
18
test/external/boost/proto/detail/preprocessed/extends_funop_const.hpp
vendored
Normal file
18
test/external/boost/proto/detail/preprocessed/extends_funop_const.hpp
vendored
Normal file
@@ -0,0 +1,18 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file extends_funop_const.hpp
|
||||
/// Definitions for extends\<\>::operator()
|
||||
//
|
||||
// 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)
|
||||
template<typename Sig> struct result { typedef typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop< Sig , proto_derived_expr , proto_domain >::type ) >::type const type; };
|
||||
typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop0< proto_derived_expr const , proto_domain >::type ) >::type const operator ()() const { typedef boost::proto::result_of::funop0< proto_derived_expr const , proto_domain > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) ) ); }
|
||||
template<typename A0> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 >::type ) >::type const operator ()(A0 const &a0) const { typedef boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 ) ); }
|
||||
template<typename A0 , typename A1> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) const { typedef boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 ) ); }
|
||||
template<typename A0 , typename A1 , typename A2> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { typedef boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 ) ); }
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { typedef boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 ) ); }
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { typedef boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 ) ); }
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { typedef boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); }
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { typedef boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 ) ); }
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { typedef boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ) ); }
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { typedef boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); }
|
||||
357
test/external/boost/proto/detail/preprocessed/funop.hpp
vendored
Normal file
357
test/external/boost/proto/detail/preprocessed/funop.hpp
vendored
Normal file
@@ -0,0 +1,357 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// funop.hpp
|
||||
// Contains definition of funop[n]\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
|
||||
|
||||
template<typename Expr, typename Domain >
|
||||
struct funop0
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list1<
|
||||
Expr &
|
||||
|
||||
>
|
||||
>::type type;
|
||||
static type const call(
|
||||
Expr &e
|
||||
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename This, typename Domain>
|
||||
struct funop<Expr(), This, Domain>
|
||||
: funop0<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template<typename Expr, typename Domain , typename A0>
|
||||
struct funop1
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list2<
|
||||
Expr &
|
||||
, typename proto::result_of::as_child<A0, Domain>::type
|
||||
>
|
||||
>::type type;
|
||||
static type const call(
|
||||
Expr &e
|
||||
, A0 &a0
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
, proto::as_child<Domain>(a0)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename A0, typename This, typename Domain>
|
||||
struct funop<Expr(A0), This, Domain>
|
||||
: funop1<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
, typename remove_reference<A0 >::type
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template<typename Expr, typename Domain , typename A0 , typename A1>
|
||||
struct funop2
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list3<
|
||||
Expr &
|
||||
, typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type
|
||||
>
|
||||
>::type type;
|
||||
static type const call(
|
||||
Expr &e
|
||||
, A0 &a0 , A1 &a1
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
, proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename A0 , typename A1, typename This, typename Domain>
|
||||
struct funop<Expr(A0 , A1), This, Domain>
|
||||
: funop2<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
, typename remove_reference<A0 >::type , typename remove_reference<A1 >::type
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2>
|
||||
struct funop3
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list4<
|
||||
Expr &
|
||||
, typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type
|
||||
>
|
||||
>::type type;
|
||||
static type const call(
|
||||
Expr &e
|
||||
, A0 &a0 , A1 &a1 , A2 &a2
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
, proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename A0 , typename A1 , typename A2, typename This, typename Domain>
|
||||
struct funop<Expr(A0 , A1 , A2), This, Domain>
|
||||
: funop3<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
, typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3>
|
||||
struct funop4
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list5<
|
||||
Expr &
|
||||
, typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type
|
||||
>
|
||||
>::type type;
|
||||
static type const call(
|
||||
Expr &e
|
||||
, A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
, proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3, typename This, typename Domain>
|
||||
struct funop<Expr(A0 , A1 , A2 , A3), This, Domain>
|
||||
: funop4<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
, typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
struct funop5
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list6<
|
||||
Expr &
|
||||
, typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type
|
||||
>
|
||||
>::type type;
|
||||
static type const call(
|
||||
Expr &e
|
||||
, A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
, proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4, typename This, typename Domain>
|
||||
struct funop<Expr(A0 , A1 , A2 , A3 , A4), This, Domain>
|
||||
: funop5<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
, typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
struct funop6
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list7<
|
||||
Expr &
|
||||
, typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type
|
||||
>
|
||||
>::type type;
|
||||
static type const call(
|
||||
Expr &e
|
||||
, A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
, proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5, typename This, typename Domain>
|
||||
struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5), This, Domain>
|
||||
: funop6<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
, typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
struct funop7
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list8<
|
||||
Expr &
|
||||
, typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type
|
||||
>
|
||||
>::type type;
|
||||
static type const call(
|
||||
Expr &e
|
||||
, A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
, proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6, typename This, typename Domain>
|
||||
struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6), This, Domain>
|
||||
: funop7<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
, typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
struct funop8
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list9<
|
||||
Expr &
|
||||
, typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type , typename proto::result_of::as_child<A7, Domain>::type
|
||||
>
|
||||
>::type type;
|
||||
static type const call(
|
||||
Expr &e
|
||||
, A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
, proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6) , proto::as_child<Domain>(a7)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7, typename This, typename Domain>
|
||||
struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), This, Domain>
|
||||
: funop8<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
, typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type , typename remove_reference<A7 >::type
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
struct funop9
|
||||
{
|
||||
typedef typename proto::base_expr<
|
||||
Domain
|
||||
, tag::function
|
||||
, list10<
|
||||
Expr &
|
||||
, typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type , typename proto::result_of::as_child<A7, Domain>::type , typename proto::result_of::as_child<A8, Domain>::type
|
||||
>
|
||||
>::type type;
|
||||
static type const call(
|
||||
Expr &e
|
||||
, A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8
|
||||
)
|
||||
{
|
||||
type that = {
|
||||
e
|
||||
, proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6) , proto::as_child<Domain>(a7) , proto::as_child<Domain>(a8)
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8, typename This, typename Domain>
|
||||
struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), This, Domain>
|
||||
: funop9<
|
||||
typename detail::same_cv<Expr, This>::type
|
||||
, Domain
|
||||
, typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type , typename remove_reference<A7 >::type , typename remove_reference<A8 >::type
|
||||
>
|
||||
{};
|
||||
467
test/external/boost/proto/detail/preprocessed/generate_by_value.hpp
vendored
Normal file
467
test/external/boost/proto/detail/preprocessed/generate_by_value.hpp
vendored
Normal file
@@ -0,0 +1,467 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file generate_by_value.hpp
|
||||
/// Contains definition of by_value_generator_\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
template<typename Tag , typename Arg0 >
|
||||
struct by_value_generator_<
|
||||
proto::expr<Tag, list1<Arg0>, 1>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list1<Arg0>
|
||||
src_args;
|
||||
typedef
|
||||
list1<
|
||||
typename uncvref<Arg0 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::expr<Tag, src_args, 1> src_type;
|
||||
typedef proto::expr<Tag, dst_args, 1> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 >
|
||||
struct by_value_generator_<
|
||||
proto::basic_expr<Tag, list1<Arg0>, 1>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list1<Arg0>
|
||||
src_args;
|
||||
typedef
|
||||
list1<
|
||||
typename uncvref<Arg0 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::basic_expr<Tag, src_args, 1> src_type;
|
||||
typedef proto::basic_expr<Tag, dst_args, 1> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 , typename Arg1 >
|
||||
struct by_value_generator_<
|
||||
proto::expr<Tag, list2<Arg0 , Arg1>, 2>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list2<Arg0 , Arg1>
|
||||
src_args;
|
||||
typedef
|
||||
list2<
|
||||
typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::expr<Tag, src_args, 2> src_type;
|
||||
typedef proto::expr<Tag, dst_args, 2> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0 , e.child1
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 , typename Arg1 >
|
||||
struct by_value_generator_<
|
||||
proto::basic_expr<Tag, list2<Arg0 , Arg1>, 2>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list2<Arg0 , Arg1>
|
||||
src_args;
|
||||
typedef
|
||||
list2<
|
||||
typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::basic_expr<Tag, src_args, 2> src_type;
|
||||
typedef proto::basic_expr<Tag, dst_args, 2> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0 , e.child1
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 >
|
||||
struct by_value_generator_<
|
||||
proto::expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list3<Arg0 , Arg1 , Arg2>
|
||||
src_args;
|
||||
typedef
|
||||
list3<
|
||||
typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::expr<Tag, src_args, 3> src_type;
|
||||
typedef proto::expr<Tag, dst_args, 3> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0 , e.child1 , e.child2
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 >
|
||||
struct by_value_generator_<
|
||||
proto::basic_expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list3<Arg0 , Arg1 , Arg2>
|
||||
src_args;
|
||||
typedef
|
||||
list3<
|
||||
typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::basic_expr<Tag, src_args, 3> src_type;
|
||||
typedef proto::basic_expr<Tag, dst_args, 3> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0 , e.child1 , e.child2
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 >
|
||||
struct by_value_generator_<
|
||||
proto::expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list4<Arg0 , Arg1 , Arg2 , Arg3>
|
||||
src_args;
|
||||
typedef
|
||||
list4<
|
||||
typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::expr<Tag, src_args, 4> src_type;
|
||||
typedef proto::expr<Tag, dst_args, 4> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0 , e.child1 , e.child2 , e.child3
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 >
|
||||
struct by_value_generator_<
|
||||
proto::basic_expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list4<Arg0 , Arg1 , Arg2 , Arg3>
|
||||
src_args;
|
||||
typedef
|
||||
list4<
|
||||
typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::basic_expr<Tag, src_args, 4> src_type;
|
||||
typedef proto::basic_expr<Tag, dst_args, 4> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0 , e.child1 , e.child2 , e.child3
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >
|
||||
struct by_value_generator_<
|
||||
proto::expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>
|
||||
src_args;
|
||||
typedef
|
||||
list5<
|
||||
typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::expr<Tag, src_args, 5> src_type;
|
||||
typedef proto::expr<Tag, dst_args, 5> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0 , e.child1 , e.child2 , e.child3 , e.child4
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >
|
||||
struct by_value_generator_<
|
||||
proto::basic_expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>
|
||||
src_args;
|
||||
typedef
|
||||
list5<
|
||||
typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::basic_expr<Tag, src_args, 5> src_type;
|
||||
typedef proto::basic_expr<Tag, dst_args, 5> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0 , e.child1 , e.child2 , e.child3 , e.child4
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >
|
||||
struct by_value_generator_<
|
||||
proto::expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>
|
||||
src_args;
|
||||
typedef
|
||||
list6<
|
||||
typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::expr<Tag, src_args, 6> src_type;
|
||||
typedef proto::expr<Tag, dst_args, 6> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >
|
||||
struct by_value_generator_<
|
||||
proto::basic_expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>
|
||||
src_args;
|
||||
typedef
|
||||
list6<
|
||||
typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::basic_expr<Tag, src_args, 6> src_type;
|
||||
typedef proto::basic_expr<Tag, dst_args, 6> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 >
|
||||
struct by_value_generator_<
|
||||
proto::expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>
|
||||
src_args;
|
||||
typedef
|
||||
list7<
|
||||
typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::expr<Tag, src_args, 7> src_type;
|
||||
typedef proto::expr<Tag, dst_args, 7> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 >
|
||||
struct by_value_generator_<
|
||||
proto::basic_expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>
|
||||
src_args;
|
||||
typedef
|
||||
list7<
|
||||
typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::basic_expr<Tag, src_args, 7> src_type;
|
||||
typedef proto::basic_expr<Tag, dst_args, 7> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 >
|
||||
struct by_value_generator_<
|
||||
proto::expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>
|
||||
src_args;
|
||||
typedef
|
||||
list8<
|
||||
typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::expr<Tag, src_args, 8> src_type;
|
||||
typedef proto::expr<Tag, dst_args, 8> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 >
|
||||
struct by_value_generator_<
|
||||
proto::basic_expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>
|
||||
src_args;
|
||||
typedef
|
||||
list8<
|
||||
typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::basic_expr<Tag, src_args, 8> src_type;
|
||||
typedef proto::basic_expr<Tag, dst_args, 8> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 >
|
||||
struct by_value_generator_<
|
||||
proto::expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>
|
||||
src_args;
|
||||
typedef
|
||||
list9<
|
||||
typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::expr<Tag, src_args, 9> src_type;
|
||||
typedef proto::expr<Tag, dst_args, 9> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 >
|
||||
struct by_value_generator_<
|
||||
proto::basic_expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>
|
||||
src_args;
|
||||
typedef
|
||||
list9<
|
||||
typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::basic_expr<Tag, src_args, 9> src_type;
|
||||
typedef proto::basic_expr<Tag, dst_args, 9> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 >
|
||||
struct by_value_generator_<
|
||||
proto::expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>
|
||||
src_args;
|
||||
typedef
|
||||
list10<
|
||||
typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type , typename uncvref<Arg9 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::expr<Tag, src_args, 10> src_type;
|
||||
typedef proto::expr<Tag, dst_args, 10> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8 , e.child9
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 >
|
||||
struct by_value_generator_<
|
||||
proto::basic_expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>
|
||||
src_args;
|
||||
typedef
|
||||
list10<
|
||||
typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type , typename uncvref<Arg9 >::type
|
||||
>
|
||||
dst_args;
|
||||
typedef proto::basic_expr<Tag, src_args, 10> src_type;
|
||||
typedef proto::basic_expr<Tag, dst_args, 10> type;
|
||||
static type const call(src_type const &e)
|
||||
{
|
||||
type that = {
|
||||
e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8 , e.child9
|
||||
};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
142
test/external/boost/proto/detail/preprocessed/lambda_matches.hpp
vendored
Normal file
142
test/external/boost/proto/detail/preprocessed/lambda_matches.hpp
vendored
Normal file
@@ -0,0 +1,142 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file lambda_matches.hpp
|
||||
/// Specializations of the lambda_matches template
|
||||
//
|
||||
// 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)
|
||||
template<
|
||||
template<typename , typename> class T
|
||||
, typename Expr0 , typename Expr1
|
||||
, typename Grammar0 , typename Grammar1
|
||||
>
|
||||
struct lambda_matches<
|
||||
T<Expr0 , Expr1>
|
||||
, T<Grammar0 , Grammar1>
|
||||
BOOST_PROTO_TEMPLATE_ARITY_PARAM(2)
|
||||
>
|
||||
: and_2<
|
||||
lambda_matches< Expr0 , Grammar0 >::value,
|
||||
lambda_matches< Expr1 , Grammar1 >
|
||||
>
|
||||
{};
|
||||
template<
|
||||
template<typename , typename , typename> class T
|
||||
, typename Expr0 , typename Expr1 , typename Expr2
|
||||
, typename Grammar0 , typename Grammar1 , typename Grammar2
|
||||
>
|
||||
struct lambda_matches<
|
||||
T<Expr0 , Expr1 , Expr2>
|
||||
, T<Grammar0 , Grammar1 , Grammar2>
|
||||
BOOST_PROTO_TEMPLATE_ARITY_PARAM(3)
|
||||
>
|
||||
: and_3<
|
||||
lambda_matches< Expr0 , Grammar0 >::value,
|
||||
lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 >
|
||||
>
|
||||
{};
|
||||
template<
|
||||
template<typename , typename , typename , typename> class T
|
||||
, typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3
|
||||
, typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3
|
||||
>
|
||||
struct lambda_matches<
|
||||
T<Expr0 , Expr1 , Expr2 , Expr3>
|
||||
, T<Grammar0 , Grammar1 , Grammar2 , Grammar3>
|
||||
BOOST_PROTO_TEMPLATE_ARITY_PARAM(4)
|
||||
>
|
||||
: and_4<
|
||||
lambda_matches< Expr0 , Grammar0 >::value,
|
||||
lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 >
|
||||
>
|
||||
{};
|
||||
template<
|
||||
template<typename , typename , typename , typename , typename> class T
|
||||
, typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4
|
||||
, typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4
|
||||
>
|
||||
struct lambda_matches<
|
||||
T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4>
|
||||
, T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4>
|
||||
BOOST_PROTO_TEMPLATE_ARITY_PARAM(5)
|
||||
>
|
||||
: and_5<
|
||||
lambda_matches< Expr0 , Grammar0 >::value,
|
||||
lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 >
|
||||
>
|
||||
{};
|
||||
template<
|
||||
template<typename , typename , typename , typename , typename , typename> class T
|
||||
, typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5
|
||||
, typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5
|
||||
>
|
||||
struct lambda_matches<
|
||||
T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5>
|
||||
, T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5>
|
||||
BOOST_PROTO_TEMPLATE_ARITY_PARAM(6)
|
||||
>
|
||||
: and_6<
|
||||
lambda_matches< Expr0 , Grammar0 >::value,
|
||||
lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 >
|
||||
>
|
||||
{};
|
||||
template<
|
||||
template<typename , typename , typename , typename , typename , typename , typename> class T
|
||||
, typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6
|
||||
, typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6
|
||||
>
|
||||
struct lambda_matches<
|
||||
T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6>
|
||||
, T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6>
|
||||
BOOST_PROTO_TEMPLATE_ARITY_PARAM(7)
|
||||
>
|
||||
: and_7<
|
||||
lambda_matches< Expr0 , Grammar0 >::value,
|
||||
lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 >
|
||||
>
|
||||
{};
|
||||
template<
|
||||
template<typename , typename , typename , typename , typename , typename , typename , typename> class T
|
||||
, typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Expr7
|
||||
, typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 , typename Grammar7
|
||||
>
|
||||
struct lambda_matches<
|
||||
T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6 , Expr7>
|
||||
, T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6 , Grammar7>
|
||||
BOOST_PROTO_TEMPLATE_ARITY_PARAM(8)
|
||||
>
|
||||
: and_8<
|
||||
lambda_matches< Expr0 , Grammar0 >::value,
|
||||
lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > , lambda_matches< Expr7 , Grammar7 >
|
||||
>
|
||||
{};
|
||||
template<
|
||||
template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class T
|
||||
, typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Expr7 , typename Expr8
|
||||
, typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 , typename Grammar7 , typename Grammar8
|
||||
>
|
||||
struct lambda_matches<
|
||||
T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6 , Expr7 , Expr8>
|
||||
, T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6 , Grammar7 , Grammar8>
|
||||
BOOST_PROTO_TEMPLATE_ARITY_PARAM(9)
|
||||
>
|
||||
: and_9<
|
||||
lambda_matches< Expr0 , Grammar0 >::value,
|
||||
lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > , lambda_matches< Expr7 , Grammar7 > , lambda_matches< Expr8 , Grammar8 >
|
||||
>
|
||||
{};
|
||||
template<
|
||||
template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class T
|
||||
, typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Expr7 , typename Expr8 , typename Expr9
|
||||
, typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 , typename Grammar7 , typename Grammar8 , typename Grammar9
|
||||
>
|
||||
struct lambda_matches<
|
||||
T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6 , Expr7 , Expr8 , Expr9>
|
||||
, T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6 , Grammar7 , Grammar8 , Grammar9>
|
||||
BOOST_PROTO_TEMPLATE_ARITY_PARAM(10)
|
||||
>
|
||||
: and_10<
|
||||
lambda_matches< Expr0 , Grammar0 >::value,
|
||||
lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > , lambda_matches< Expr7 , Grammar7 > , lambda_matches< Expr8 , Grammar8 > , lambda_matches< Expr9 , Grammar9 >
|
||||
>
|
||||
{};
|
||||
313
test/external/boost/proto/detail/preprocessed/make_expr.hpp
vendored
Normal file
313
test/external/boost/proto/detail/preprocessed/make_expr.hpp
vendored
Normal file
@@ -0,0 +1,313 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file make_expr.hpp
|
||||
/// Contains overloads of make_expr() free function.
|
||||
//
|
||||
// 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)
|
||||
|
||||
|
||||
template<typename Tag , typename A0 , typename A1>
|
||||
typename lazy_disable_if<
|
||||
is_domain<A0>
|
||||
, result_of::make_expr<
|
||||
Tag
|
||||
, const A0 , const A1
|
||||
>
|
||||
>::type const
|
||||
make_expr(const A0 &a0 , const A1 &a1)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, deduce_domain
|
||||
, const A0 , const A1
|
||||
>()(a0 , a1);
|
||||
}
|
||||
|
||||
|
||||
template<typename Tag, typename Domain , typename C0 , typename C1>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, const C0 , const C1
|
||||
>::type const
|
||||
make_expr(const C0 &c0 , const C1 &c1)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, const C0 , const C1
|
||||
>()(c0 , c1);
|
||||
}
|
||||
|
||||
|
||||
template<typename Tag , typename A0 , typename A1 , typename A2>
|
||||
typename lazy_disable_if<
|
||||
is_domain<A0>
|
||||
, result_of::make_expr<
|
||||
Tag
|
||||
, const A0 , const A1 , const A2
|
||||
>
|
||||
>::type const
|
||||
make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, deduce_domain
|
||||
, const A0 , const A1 , const A2
|
||||
>()(a0 , a1 , a2);
|
||||
}
|
||||
|
||||
|
||||
template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, const C0 , const C1 , const C2
|
||||
>::type const
|
||||
make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, const C0 , const C1 , const C2
|
||||
>()(c0 , c1 , c2);
|
||||
}
|
||||
|
||||
|
||||
template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3>
|
||||
typename lazy_disable_if<
|
||||
is_domain<A0>
|
||||
, result_of::make_expr<
|
||||
Tag
|
||||
, const A0 , const A1 , const A2 , const A3
|
||||
>
|
||||
>::type const
|
||||
make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, deduce_domain
|
||||
, const A0 , const A1 , const A2 , const A3
|
||||
>()(a0 , a1 , a2 , a3);
|
||||
}
|
||||
|
||||
|
||||
template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, const C0 , const C1 , const C2 , const C3
|
||||
>::type const
|
||||
make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, const C0 , const C1 , const C2 , const C3
|
||||
>()(c0 , c1 , c2 , c3);
|
||||
}
|
||||
|
||||
|
||||
template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
typename lazy_disable_if<
|
||||
is_domain<A0>
|
||||
, result_of::make_expr<
|
||||
Tag
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4
|
||||
>
|
||||
>::type const
|
||||
make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, deduce_domain
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4
|
||||
>()(a0 , a1 , a2 , a3 , a4);
|
||||
}
|
||||
|
||||
|
||||
template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, const C0 , const C1 , const C2 , const C3 , const C4
|
||||
>::type const
|
||||
make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, const C0 , const C1 , const C2 , const C3 , const C4
|
||||
>()(c0 , c1 , c2 , c3 , c4);
|
||||
}
|
||||
|
||||
|
||||
template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
typename lazy_disable_if<
|
||||
is_domain<A0>
|
||||
, result_of::make_expr<
|
||||
Tag
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5
|
||||
>
|
||||
>::type const
|
||||
make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, deduce_domain
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5
|
||||
>()(a0 , a1 , a2 , a3 , a4 , a5);
|
||||
}
|
||||
|
||||
|
||||
template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, const C0 , const C1 , const C2 , const C3 , const C4 , const C5
|
||||
>::type const
|
||||
make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, const C0 , const C1 , const C2 , const C3 , const C4 , const C5
|
||||
>()(c0 , c1 , c2 , c3 , c4 , c5);
|
||||
}
|
||||
|
||||
|
||||
template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
typename lazy_disable_if<
|
||||
is_domain<A0>
|
||||
, result_of::make_expr<
|
||||
Tag
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
|
||||
>
|
||||
>::type const
|
||||
make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, deduce_domain
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
|
||||
>()(a0 , a1 , a2 , a3 , a4 , a5 , a6);
|
||||
}
|
||||
|
||||
|
||||
template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6
|
||||
>::type const
|
||||
make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6
|
||||
>()(c0 , c1 , c2 , c3 , c4 , c5 , c6);
|
||||
}
|
||||
|
||||
|
||||
template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
typename lazy_disable_if<
|
||||
is_domain<A0>
|
||||
, result_of::make_expr<
|
||||
Tag
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
|
||||
>
|
||||
>::type const
|
||||
make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, deduce_domain
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
|
||||
>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
|
||||
}
|
||||
|
||||
|
||||
template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7
|
||||
>::type const
|
||||
make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6 , const C7 &c7)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7
|
||||
>()(c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7);
|
||||
}
|
||||
|
||||
|
||||
template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
typename lazy_disable_if<
|
||||
is_domain<A0>
|
||||
, result_of::make_expr<
|
||||
Tag
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
|
||||
>
|
||||
>::type const
|
||||
make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, deduce_domain
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
|
||||
>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
|
||||
}
|
||||
|
||||
|
||||
template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8
|
||||
>::type const
|
||||
make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6 , const C7 &c7 , const C8 &c8)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8
|
||||
>()(c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8);
|
||||
}
|
||||
|
||||
|
||||
template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
typename lazy_disable_if<
|
||||
is_domain<A0>
|
||||
, result_of::make_expr<
|
||||
Tag
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9
|
||||
>
|
||||
>::type const
|
||||
make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8 , const A9 &a9)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, deduce_domain
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9
|
||||
>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
|
||||
}
|
||||
|
||||
|
||||
template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8 , typename C9>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8 , const C9
|
||||
>::type const
|
||||
make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6 , const C7 &c7 , const C8 &c8 , const C9 &c9)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8 , const C9
|
||||
>()(c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9);
|
||||
}
|
||||
320
test/external/boost/proto/detail/preprocessed/make_expr_.hpp
vendored
Normal file
320
test/external/boost/proto/detail/preprocessed/make_expr_.hpp
vendored
Normal file
@@ -0,0 +1,320 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file make_expr_.hpp
|
||||
/// Contains definition of make_expr_\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
template<
|
||||
typename Tag
|
||||
, typename Domain
|
||||
, typename A0 = void , typename A1 = void , typename A2 = void , typename A3 = void , typename A4 = void , typename A5 = void , typename A6 = void , typename A7 = void , typename A8 = void , typename A9 = void
|
||||
, typename _ = void
|
||||
>
|
||||
struct make_expr_
|
||||
{};
|
||||
template<typename Domain, typename A>
|
||||
struct make_expr_<tag::terminal, Domain, A
|
||||
, void , void , void , void , void , void , void , void , void , void>
|
||||
{
|
||||
typedef typename proto::detail::protoify<A, Domain>::result_type result_type;
|
||||
result_type operator()(typename add_reference<A>::type a) const
|
||||
{
|
||||
return proto::detail::protoify<A, Domain>()(a);
|
||||
}
|
||||
};
|
||||
template<typename A>
|
||||
struct make_expr_<tag::terminal, deduce_domain, A
|
||||
, void , void , void , void , void , void , void , void , void , void>
|
||||
: make_expr_<tag::terminal, default_domain, A>
|
||||
{};
|
||||
template<typename Tag, typename Domain , typename A0>
|
||||
struct make_expr_<Tag, Domain , A0
|
||||
, void , void , void , void , void , void , void , void , void, void>
|
||||
{
|
||||
typedef
|
||||
list1<
|
||||
typename boost::proto::detail::protoify< A0 , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
result_type operator()(typename add_reference<A0 >::type a0) const
|
||||
{
|
||||
expr_type const that = {
|
||||
boost::proto::detail::protoify< A0 , Domain >()(a0)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename A0>
|
||||
struct make_expr_<Tag, deduce_domain , A0
|
||||
, void , void , void , void , void , void , void , void , void, void>
|
||||
: make_expr_<
|
||||
Tag
|
||||
, typename deduce_domain1<A0>::type
|
||||
, A0
|
||||
>
|
||||
{};
|
||||
template<typename Tag, typename Domain , typename A0 , typename A1>
|
||||
struct make_expr_<Tag, Domain , A0 , A1
|
||||
, void , void , void , void , void , void , void , void, void>
|
||||
{
|
||||
typedef
|
||||
list2<
|
||||
typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1) const
|
||||
{
|
||||
expr_type const that = {
|
||||
boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename A0 , typename A1>
|
||||
struct make_expr_<Tag, deduce_domain , A0 , A1
|
||||
, void , void , void , void , void , void , void , void, void>
|
||||
: make_expr_<
|
||||
Tag
|
||||
, typename deduce_domain2<A0 , A1>::type
|
||||
, A0 , A1
|
||||
>
|
||||
{};
|
||||
template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2>
|
||||
struct make_expr_<Tag, Domain , A0 , A1 , A2
|
||||
, void , void , void , void , void , void , void, void>
|
||||
{
|
||||
typedef
|
||||
list3<
|
||||
typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2) const
|
||||
{
|
||||
expr_type const that = {
|
||||
boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename A0 , typename A1 , typename A2>
|
||||
struct make_expr_<Tag, deduce_domain , A0 , A1 , A2
|
||||
, void , void , void , void , void , void , void, void>
|
||||
: make_expr_<
|
||||
Tag
|
||||
, typename deduce_domain3<A0 , A1 , A2>::type
|
||||
, A0 , A1 , A2
|
||||
>
|
||||
{};
|
||||
template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3>
|
||||
struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3
|
||||
, void , void , void , void , void , void, void>
|
||||
{
|
||||
typedef
|
||||
list4<
|
||||
typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3) const
|
||||
{
|
||||
expr_type const that = {
|
||||
boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3>
|
||||
struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3
|
||||
, void , void , void , void , void , void, void>
|
||||
: make_expr_<
|
||||
Tag
|
||||
, typename deduce_domain4<A0 , A1 , A2 , A3>::type
|
||||
, A0 , A1 , A2 , A3
|
||||
>
|
||||
{};
|
||||
template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4
|
||||
, void , void , void , void , void, void>
|
||||
{
|
||||
typedef
|
||||
list5<
|
||||
typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4) const
|
||||
{
|
||||
expr_type const that = {
|
||||
boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4
|
||||
, void , void , void , void , void, void>
|
||||
: make_expr_<
|
||||
Tag
|
||||
, typename deduce_domain5<A0 , A1 , A2 , A3 , A4>::type
|
||||
, A0 , A1 , A2 , A3 , A4
|
||||
>
|
||||
{};
|
||||
template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5
|
||||
, void , void , void , void, void>
|
||||
{
|
||||
typedef
|
||||
list6<
|
||||
typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5) const
|
||||
{
|
||||
expr_type const that = {
|
||||
boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5
|
||||
, void , void , void , void, void>
|
||||
: make_expr_<
|
||||
Tag
|
||||
, typename deduce_domain6<A0 , A1 , A2 , A3 , A4 , A5>::type
|
||||
, A0 , A1 , A2 , A3 , A4 , A5
|
||||
>
|
||||
{};
|
||||
template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6
|
||||
, void , void , void, void>
|
||||
{
|
||||
typedef
|
||||
list7<
|
||||
typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6) const
|
||||
{
|
||||
expr_type const that = {
|
||||
boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6
|
||||
, void , void , void, void>
|
||||
: make_expr_<
|
||||
Tag
|
||||
, typename deduce_domain7<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6
|
||||
>
|
||||
{};
|
||||
template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
|
||||
, void , void, void>
|
||||
{
|
||||
typedef
|
||||
list8<
|
||||
typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7) const
|
||||
{
|
||||
expr_type const that = {
|
||||
boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
|
||||
, void , void, void>
|
||||
: make_expr_<
|
||||
Tag
|
||||
, typename deduce_domain8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
|
||||
>
|
||||
{};
|
||||
template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
|
||||
, void, void>
|
||||
{
|
||||
typedef
|
||||
list9<
|
||||
typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type , typename boost::proto::detail::protoify< A8 , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7 , typename add_reference<A8 >::type a8) const
|
||||
{
|
||||
expr_type const that = {
|
||||
boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7) , boost::proto::detail::protoify< A8 , Domain >()(a8)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
|
||||
, void, void>
|
||||
: make_expr_<
|
||||
Tag
|
||||
, typename deduce_domain9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
|
||||
>
|
||||
{};
|
||||
template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
|
||||
, void>
|
||||
{
|
||||
typedef
|
||||
list10<
|
||||
typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type , typename boost::proto::detail::protoify< A8 , Domain >::result_type , typename boost::proto::detail::protoify< A9 , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
|
||||
result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7 , typename add_reference<A8 >::type a8 , typename add_reference<A9 >::type a9) const
|
||||
{
|
||||
expr_type const that = {
|
||||
boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7) , boost::proto::detail::protoify< A8 , Domain >()(a8) , boost::proto::detail::protoify< A9 , Domain >()(a9)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
|
||||
, void>
|
||||
: make_expr_<
|
||||
Tag
|
||||
, typename deduce_domain10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>::type
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
|
||||
>
|
||||
{};
|
||||
250
test/external/boost/proto/detail/preprocessed/make_expr_funop.hpp
vendored
Normal file
250
test/external/boost/proto/detail/preprocessed/make_expr_funop.hpp
vendored
Normal file
@@ -0,0 +1,250 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file make_expr_funop.hpp
|
||||
/// Contains definition of make_expr\<\>::operator() member functions.
|
||||
//
|
||||
// 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)
|
||||
template<typename This , typename A0 , typename A1>
|
||||
struct result<This(A0 , A1)>
|
||||
{
|
||||
typedef
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, A0 , A1
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
|
||||
template<typename A0 , typename A1>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, const A0 , const A1
|
||||
>::type const
|
||||
operator ()(const A0 &a0 , const A1 &a1) const
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, const A0 , const A1
|
||||
>()(a0 , a1);
|
||||
}
|
||||
template<typename This , typename A0 , typename A1 , typename A2>
|
||||
struct result<This(A0 , A1 , A2)>
|
||||
{
|
||||
typedef
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, A0 , A1 , A2
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
|
||||
template<typename A0 , typename A1 , typename A2>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, const A0 , const A1 , const A2
|
||||
>::type const
|
||||
operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2) const
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, const A0 , const A1 , const A2
|
||||
>()(a0 , a1 , a2);
|
||||
}
|
||||
template<typename This , typename A0 , typename A1 , typename A2 , typename A3>
|
||||
struct result<This(A0 , A1 , A2 , A3)>
|
||||
{
|
||||
typedef
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, A0 , A1 , A2 , A3
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, const A0 , const A1 , const A2 , const A3
|
||||
>::type const
|
||||
operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3) const
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, const A0 , const A1 , const A2 , const A3
|
||||
>()(a0 , a1 , a2 , a3);
|
||||
}
|
||||
template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
struct result<This(A0 , A1 , A2 , A3 , A4)>
|
||||
{
|
||||
typedef
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, A0 , A1 , A2 , A3 , A4
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4
|
||||
>::type const
|
||||
operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4) const
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4
|
||||
>()(a0 , a1 , a2 , a3 , a4);
|
||||
}
|
||||
template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
struct result<This(A0 , A1 , A2 , A3 , A4 , A5)>
|
||||
{
|
||||
typedef
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, A0 , A1 , A2 , A3 , A4 , A5
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5
|
||||
>::type const
|
||||
operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5) const
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5
|
||||
>()(a0 , a1 , a2 , a3 , a4 , a5);
|
||||
}
|
||||
template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
|
||||
{
|
||||
typedef
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
|
||||
>::type const
|
||||
operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6) const
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
|
||||
>()(a0 , a1 , a2 , a3 , a4 , a5 , a6);
|
||||
}
|
||||
template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
|
||||
{
|
||||
typedef
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
|
||||
>::type const
|
||||
operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7) const
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
|
||||
>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
|
||||
}
|
||||
template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
|
||||
{
|
||||
typedef
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
|
||||
>::type const
|
||||
operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8) const
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
|
||||
>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
|
||||
}
|
||||
template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
|
||||
{
|
||||
typedef
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9
|
||||
>::type const
|
||||
operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8 , const A9 &a9) const
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9
|
||||
>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
|
||||
}
|
||||
277
test/external/boost/proto/detail/preprocessed/matches_.hpp
vendored
Normal file
277
test/external/boost/proto/detail/preprocessed/matches_.hpp
vendored
Normal file
@@ -0,0 +1,277 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file matches_.hpp
|
||||
/// Definitions of matches_ specializations
|
||||
//
|
||||
// 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)
|
||||
|
||||
template<typename Expr, typename BasicExpr , typename G0 , typename G1>
|
||||
struct matches_<Expr, BasicExpr, proto::or_<G0 , G1> >
|
||||
: or_2<
|
||||
matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
|
||||
Expr, BasicExpr , G0 , G1
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr, typename G0 , typename G1>
|
||||
struct matches_<Expr, BasicExpr, proto::and_<G0 , G1> >
|
||||
: detail::and_2<
|
||||
matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
|
||||
matches_< Expr , BasicExpr , typename G1::proto_grammar >
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 2>, proto::basic_expr<Tag, Args2, 2> >
|
||||
: and_2<
|
||||
matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
|
||||
matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar >
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 2>, proto::basic_expr<proto::_, Args2, 2> >
|
||||
: and_2<
|
||||
matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
|
||||
matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar >
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2>
|
||||
struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2> >
|
||||
: or_3<
|
||||
matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
|
||||
Expr, BasicExpr , G0 , G1 , G2
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2>
|
||||
struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2> >
|
||||
: detail::and_3<
|
||||
matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
|
||||
matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar >
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 3>, proto::basic_expr<Tag, Args2, 3> >
|
||||
: and_3<
|
||||
matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
|
||||
matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar >
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 3>, proto::basic_expr<proto::_, Args2, 3> >
|
||||
: and_3<
|
||||
matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
|
||||
matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar >
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3>
|
||||
struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3> >
|
||||
: or_4<
|
||||
matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
|
||||
Expr, BasicExpr , G0 , G1 , G2 , G3
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3>
|
||||
struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3> >
|
||||
: detail::and_4<
|
||||
matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
|
||||
matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar >
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 4>, proto::basic_expr<Tag, Args2, 4> >
|
||||
: and_4<
|
||||
matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
|
||||
matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar >
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 4>, proto::basic_expr<proto::_, Args2, 4> >
|
||||
: and_4<
|
||||
matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
|
||||
matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar >
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4>
|
||||
struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4> >
|
||||
: or_5<
|
||||
matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
|
||||
Expr, BasicExpr , G0 , G1 , G2 , G3 , G4
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4>
|
||||
struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4> >
|
||||
: detail::and_5<
|
||||
matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
|
||||
matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar >
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 5>, proto::basic_expr<Tag, Args2, 5> >
|
||||
: and_5<
|
||||
matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
|
||||
matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar >
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 5>, proto::basic_expr<proto::_, Args2, 5> >
|
||||
: and_5<
|
||||
matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
|
||||
matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar >
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5>
|
||||
struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5> >
|
||||
: or_6<
|
||||
matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
|
||||
Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5>
|
||||
struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5> >
|
||||
: detail::and_6<
|
||||
matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
|
||||
matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar >
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 6>, proto::basic_expr<Tag, Args2, 6> >
|
||||
: and_6<
|
||||
matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
|
||||
matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar >
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 6>, proto::basic_expr<proto::_, Args2, 6> >
|
||||
: and_6<
|
||||
matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
|
||||
matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar >
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6>
|
||||
struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6> >
|
||||
: or_7<
|
||||
matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
|
||||
Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6>
|
||||
struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6> >
|
||||
: detail::and_7<
|
||||
matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
|
||||
matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar >
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 7>, proto::basic_expr<Tag, Args2, 7> >
|
||||
: and_7<
|
||||
matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
|
||||
matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar >
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 7>, proto::basic_expr<proto::_, Args2, 7> >
|
||||
: and_7<
|
||||
matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
|
||||
matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar >
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7>
|
||||
struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7> >
|
||||
: or_8<
|
||||
matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
|
||||
Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7>
|
||||
struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7> >
|
||||
: detail::and_8<
|
||||
matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
|
||||
matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > , matches_< Expr , BasicExpr , typename G7::proto_grammar >
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 8>, proto::basic_expr<Tag, Args2, 8> >
|
||||
: and_8<
|
||||
matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
|
||||
matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar >
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 8>, proto::basic_expr<proto::_, Args2, 8> >
|
||||
: and_8<
|
||||
matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
|
||||
matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar >
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8>
|
||||
struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8> >
|
||||
: or_9<
|
||||
matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
|
||||
Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8>
|
||||
struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8> >
|
||||
: detail::and_9<
|
||||
matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
|
||||
matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > , matches_< Expr , BasicExpr , typename G7::proto_grammar > , matches_< Expr , BasicExpr , typename G8::proto_grammar >
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 9>, proto::basic_expr<Tag, Args2, 9> >
|
||||
: and_9<
|
||||
matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
|
||||
matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar >
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 9>, proto::basic_expr<proto::_, Args2, 9> >
|
||||
: and_9<
|
||||
matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
|
||||
matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar >
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
|
||||
struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9> >
|
||||
: or_10<
|
||||
matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
|
||||
Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
|
||||
struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9> >
|
||||
: detail::and_10<
|
||||
matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
|
||||
matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > , matches_< Expr , BasicExpr , typename G7::proto_grammar > , matches_< Expr , BasicExpr , typename G8::proto_grammar > , matches_< Expr , BasicExpr , typename G9::proto_grammar >
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 10>, proto::basic_expr<Tag, Args2, 10> >
|
||||
: and_10<
|
||||
matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
|
||||
matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child9>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child9>::value_type::proto_grammar , typename Args2::child9::proto_grammar >
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 10>, proto::basic_expr<proto::_, Args2, 10> >
|
||||
: and_10<
|
||||
matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
|
||||
matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child9>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child9>::value_type::proto_grammar , typename Args2::child9::proto_grammar >
|
||||
>
|
||||
{};
|
||||
67
test/external/boost/proto/detail/preprocessed/memfun_funop.hpp
vendored
Normal file
67
test/external/boost/proto/detail/preprocessed/memfun_funop.hpp
vendored
Normal file
@@ -0,0 +1,67 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// memfun_funop.hpp
|
||||
// Contains overloads of memfun::operator().
|
||||
//
|
||||
// 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)
|
||||
template<typename A0>
|
||||
result_type operator()(A0 const &a0) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0);
|
||||
}
|
||||
template<typename A0 , typename A1>
|
||||
result_type operator()(A0 const &a0 , A1 const &a1) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1);
|
||||
}
|
||||
template<typename A0 , typename A1 , typename A2>
|
||||
result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2);
|
||||
}
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3>
|
||||
result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3);
|
||||
}
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4);
|
||||
}
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5);
|
||||
}
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6);
|
||||
}
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
|
||||
}
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
|
||||
}
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9) const
|
||||
{
|
||||
BOOST_PROTO_USE_GET_POINTER();
|
||||
return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
|
||||
}
|
||||
123
test/external/boost/proto/detail/preprocessed/or_n.hpp
vendored
Normal file
123
test/external/boost/proto/detail/preprocessed/or_n.hpp
vendored
Normal file
@@ -0,0 +1,123 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file or_n.hpp
|
||||
/// Definitions of or_N
|
||||
//
|
||||
// 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)
|
||||
template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1>
|
||||
struct or_2
|
||||
: mpl::bool_<matches_<Expr, BasicExpr, typename G1::proto_grammar>::value>
|
||||
{
|
||||
typedef G1 which;
|
||||
};
|
||||
template<typename Expr, typename BasicExpr , typename G0 , typename G1>
|
||||
struct or_2<true, Expr, BasicExpr, G0 , G1>
|
||||
: mpl::true_
|
||||
{
|
||||
typedef G0 which;
|
||||
};
|
||||
template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2>
|
||||
struct or_3
|
||||
: or_2<
|
||||
matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
|
||||
, Expr, BasicExpr, G1 , G2
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2>
|
||||
struct or_3<true, Expr, BasicExpr, G0 , G1 , G2>
|
||||
: mpl::true_
|
||||
{
|
||||
typedef G0 which;
|
||||
};
|
||||
template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3>
|
||||
struct or_4
|
||||
: or_3<
|
||||
matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
|
||||
, Expr, BasicExpr, G1 , G2 , G3
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3>
|
||||
struct or_4<true, Expr, BasicExpr, G0 , G1 , G2 , G3>
|
||||
: mpl::true_
|
||||
{
|
||||
typedef G0 which;
|
||||
};
|
||||
template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4>
|
||||
struct or_5
|
||||
: or_4<
|
||||
matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
|
||||
, Expr, BasicExpr, G1 , G2 , G3 , G4
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4>
|
||||
struct or_5<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4>
|
||||
: mpl::true_
|
||||
{
|
||||
typedef G0 which;
|
||||
};
|
||||
template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5>
|
||||
struct or_6
|
||||
: or_5<
|
||||
matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
|
||||
, Expr, BasicExpr, G1 , G2 , G3 , G4 , G5
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5>
|
||||
struct or_6<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5>
|
||||
: mpl::true_
|
||||
{
|
||||
typedef G0 which;
|
||||
};
|
||||
template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6>
|
||||
struct or_7
|
||||
: or_6<
|
||||
matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
|
||||
, Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6>
|
||||
struct or_7<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6>
|
||||
: mpl::true_
|
||||
{
|
||||
typedef G0 which;
|
||||
};
|
||||
template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7>
|
||||
struct or_8
|
||||
: or_7<
|
||||
matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
|
||||
, Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 , G7
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7>
|
||||
struct or_8<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7>
|
||||
: mpl::true_
|
||||
{
|
||||
typedef G0 which;
|
||||
};
|
||||
template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8>
|
||||
struct or_9
|
||||
: or_8<
|
||||
matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
|
||||
, Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8>
|
||||
struct or_9<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8>
|
||||
: mpl::true_
|
||||
{
|
||||
typedef G0 which;
|
||||
};
|
||||
template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
|
||||
struct or_10
|
||||
: or_9<
|
||||
matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
|
||||
, Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9
|
||||
>
|
||||
{};
|
||||
template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
|
||||
struct or_10<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9>
|
||||
: mpl::true_
|
||||
{
|
||||
typedef G0 which;
|
||||
};
|
||||
237
test/external/boost/proto/detail/preprocessed/poly_function_funop.hpp
vendored
Normal file
237
test/external/boost/proto/detail/preprocessed/poly_function_funop.hpp
vendored
Normal file
@@ -0,0 +1,237 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// poly_function_funop.hpp
|
||||
// Contains overloads of poly_function\<\>::operator()
|
||||
//
|
||||
// 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)
|
||||
template<typename This , typename A0>
|
||||
struct result<This(A0)>
|
||||
: Derived::template impl<
|
||||
typename normalize_arg<A0 >::type
|
||||
>
|
||||
{
|
||||
typedef typename result::result_type type;
|
||||
};
|
||||
template<typename A0>
|
||||
typename result<
|
||||
Derived const(
|
||||
A0 const &
|
||||
)
|
||||
>::type
|
||||
operator ()(A0 const &a0) const
|
||||
{
|
||||
result<
|
||||
Derived const(
|
||||
A0 const &
|
||||
)
|
||||
> impl;
|
||||
return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0));
|
||||
}
|
||||
template<typename This , typename A0 , typename A1>
|
||||
struct result<This(A0 , A1)>
|
||||
: Derived::template impl<
|
||||
typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type
|
||||
>
|
||||
{
|
||||
typedef typename result::result_type type;
|
||||
};
|
||||
template<typename A0 , typename A1>
|
||||
typename result<
|
||||
Derived const(
|
||||
A0 const & , A1 const &
|
||||
)
|
||||
>::type
|
||||
operator ()(A0 const &a0 , A1 const &a1) const
|
||||
{
|
||||
result<
|
||||
Derived const(
|
||||
A0 const & , A1 const &
|
||||
)
|
||||
> impl;
|
||||
return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1));
|
||||
}
|
||||
template<typename This , typename A0 , typename A1 , typename A2>
|
||||
struct result<This(A0 , A1 , A2)>
|
||||
: Derived::template impl<
|
||||
typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type
|
||||
>
|
||||
{
|
||||
typedef typename result::result_type type;
|
||||
};
|
||||
template<typename A0 , typename A1 , typename A2>
|
||||
typename result<
|
||||
Derived const(
|
||||
A0 const & , A1 const & , A2 const &
|
||||
)
|
||||
>::type
|
||||
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
|
||||
{
|
||||
result<
|
||||
Derived const(
|
||||
A0 const & , A1 const & , A2 const &
|
||||
)
|
||||
> impl;
|
||||
return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2));
|
||||
}
|
||||
template<typename This , typename A0 , typename A1 , typename A2 , typename A3>
|
||||
struct result<This(A0 , A1 , A2 , A3)>
|
||||
: Derived::template impl<
|
||||
typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type
|
||||
>
|
||||
{
|
||||
typedef typename result::result_type type;
|
||||
};
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3>
|
||||
typename result<
|
||||
Derived const(
|
||||
A0 const & , A1 const & , A2 const & , A3 const &
|
||||
)
|
||||
>::type
|
||||
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
|
||||
{
|
||||
result<
|
||||
Derived const(
|
||||
A0 const & , A1 const & , A2 const & , A3 const &
|
||||
)
|
||||
> impl;
|
||||
return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3));
|
||||
}
|
||||
template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
struct result<This(A0 , A1 , A2 , A3 , A4)>
|
||||
: Derived::template impl<
|
||||
typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type
|
||||
>
|
||||
{
|
||||
typedef typename result::result_type type;
|
||||
};
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
typename result<
|
||||
Derived const(
|
||||
A0 const & , A1 const & , A2 const & , A3 const & , A4 const &
|
||||
)
|
||||
>::type
|
||||
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
|
||||
{
|
||||
result<
|
||||
Derived const(
|
||||
A0 const & , A1 const & , A2 const & , A3 const & , A4 const &
|
||||
)
|
||||
> impl;
|
||||
return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4));
|
||||
}
|
||||
template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
struct result<This(A0 , A1 , A2 , A3 , A4 , A5)>
|
||||
: Derived::template impl<
|
||||
typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type
|
||||
>
|
||||
{
|
||||
typedef typename result::result_type type;
|
||||
};
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
typename result<
|
||||
Derived const(
|
||||
A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const &
|
||||
)
|
||||
>::type
|
||||
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
|
||||
{
|
||||
result<
|
||||
Derived const(
|
||||
A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const &
|
||||
)
|
||||
> impl;
|
||||
return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5));
|
||||
}
|
||||
template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
|
||||
: Derived::template impl<
|
||||
typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type
|
||||
>
|
||||
{
|
||||
typedef typename result::result_type type;
|
||||
};
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
typename result<
|
||||
Derived const(
|
||||
A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const &
|
||||
)
|
||||
>::type
|
||||
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
|
||||
{
|
||||
result<
|
||||
Derived const(
|
||||
A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const &
|
||||
)
|
||||
> impl;
|
||||
return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6));
|
||||
}
|
||||
template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
|
||||
: Derived::template impl<
|
||||
typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type , typename normalize_arg<A7 >::type
|
||||
>
|
||||
{
|
||||
typedef typename result::result_type type;
|
||||
};
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
typename result<
|
||||
Derived const(
|
||||
A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const &
|
||||
)
|
||||
>::type
|
||||
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
|
||||
{
|
||||
result<
|
||||
Derived const(
|
||||
A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const &
|
||||
)
|
||||
> impl;
|
||||
return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6) , static_cast<typename normalize_arg<A7 const &> ::reference>(a7));
|
||||
}
|
||||
template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
|
||||
: Derived::template impl<
|
||||
typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type , typename normalize_arg<A7 >::type , typename normalize_arg<A8 >::type
|
||||
>
|
||||
{
|
||||
typedef typename result::result_type type;
|
||||
};
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
typename result<
|
||||
Derived const(
|
||||
A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const &
|
||||
)
|
||||
>::type
|
||||
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
|
||||
{
|
||||
result<
|
||||
Derived const(
|
||||
A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const &
|
||||
)
|
||||
> impl;
|
||||
return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6) , static_cast<typename normalize_arg<A7 const &> ::reference>(a7) , static_cast<typename normalize_arg<A8 const &> ::reference>(a8));
|
||||
}
|
||||
template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
|
||||
: Derived::template impl<
|
||||
typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type , typename normalize_arg<A7 >::type , typename normalize_arg<A8 >::type , typename normalize_arg<A9 >::type
|
||||
>
|
||||
{
|
||||
typedef typename result::result_type type;
|
||||
};
|
||||
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
typename result<
|
||||
Derived const(
|
||||
A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const & , A9 const &
|
||||
)
|
||||
>::type
|
||||
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9) const
|
||||
{
|
||||
result<
|
||||
Derived const(
|
||||
A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const & , A9 const &
|
||||
)
|
||||
> impl;
|
||||
return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6) , static_cast<typename normalize_arg<A7 const &> ::reference>(a7) , static_cast<typename normalize_arg<A8 const &> ::reference>(a8) , static_cast<typename normalize_arg<A9 const &> ::reference>(a9));
|
||||
}
|
||||
247
test/external/boost/proto/detail/preprocessed/poly_function_traits.hpp
vendored
Normal file
247
test/external/boost/proto/detail/preprocessed/poly_function_traits.hpp
vendored
Normal file
@@ -0,0 +1,247 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// poly_function_traits.hpp
|
||||
// Contains specializations of poly_function_traits and as_mono_function
|
||||
//
|
||||
// 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)
|
||||
|
||||
template<typename PolyFun , typename A0>
|
||||
struct poly_function_traits<PolyFun, PolyFun(A0), mpl::size_t<sizeof(poly_function_t)> >
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0> function_type;
|
||||
typedef typename function_type::result_type result_type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0>
|
||||
struct as_mono_function_impl<PolyFun(A0), true>
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0> type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0>
|
||||
struct as_mono_function_impl<PolyFun(A0), false>
|
||||
{
|
||||
typedef PolyFun type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0>
|
||||
struct as_mono_function<PolyFun(A0)>
|
||||
: as_mono_function_impl<PolyFun(A0), is_poly_function<PolyFun>::value>
|
||||
{};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1>
|
||||
struct poly_function_traits<PolyFun, PolyFun(A0 , A1), mpl::size_t<sizeof(poly_function_t)> >
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0 , const A1> function_type;
|
||||
typedef typename function_type::result_type result_type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1>
|
||||
struct as_mono_function_impl<PolyFun(A0 , A1), true>
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0 , const A1> type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1>
|
||||
struct as_mono_function_impl<PolyFun(A0 , A1), false>
|
||||
{
|
||||
typedef PolyFun type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1>
|
||||
struct as_mono_function<PolyFun(A0 , A1)>
|
||||
: as_mono_function_impl<PolyFun(A0 , A1), is_poly_function<PolyFun>::value>
|
||||
{};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2>
|
||||
struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2), mpl::size_t<sizeof(poly_function_t)> >
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0 , const A1 , const A2> function_type;
|
||||
typedef typename function_type::result_type result_type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2>
|
||||
struct as_mono_function_impl<PolyFun(A0 , A1 , A2), true>
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0 , const A1 , const A2> type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2>
|
||||
struct as_mono_function_impl<PolyFun(A0 , A1 , A2), false>
|
||||
{
|
||||
typedef PolyFun type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2>
|
||||
struct as_mono_function<PolyFun(A0 , A1 , A2)>
|
||||
: as_mono_function_impl<PolyFun(A0 , A1 , A2), is_poly_function<PolyFun>::value>
|
||||
{};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3>
|
||||
struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3), mpl::size_t<sizeof(poly_function_t)> >
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3> function_type;
|
||||
typedef typename function_type::result_type result_type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3>
|
||||
struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3), true>
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3> type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3>
|
||||
struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3), false>
|
||||
{
|
||||
typedef PolyFun type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3>
|
||||
struct as_mono_function<PolyFun(A0 , A1 , A2 , A3)>
|
||||
: as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3), is_poly_function<PolyFun>::value>
|
||||
{};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4), mpl::size_t<sizeof(poly_function_t)> >
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4> function_type;
|
||||
typedef typename function_type::result_type result_type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4), true>
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4> type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4), false>
|
||||
{
|
||||
typedef PolyFun type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4)>
|
||||
: as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4), is_poly_function<PolyFun>::value>
|
||||
{};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5), mpl::size_t<sizeof(poly_function_t)> >
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5> function_type;
|
||||
typedef typename function_type::result_type result_type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5), true>
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5> type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5), false>
|
||||
{
|
||||
typedef PolyFun type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5)>
|
||||
: as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5), is_poly_function<PolyFun>::value>
|
||||
{};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), mpl::size_t<sizeof(poly_function_t)> >
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6> function_type;
|
||||
typedef typename function_type::result_type result_type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), true>
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6> type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), false>
|
||||
{
|
||||
typedef PolyFun type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
|
||||
: as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), is_poly_function<PolyFun>::value>
|
||||
{};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), mpl::size_t<sizeof(poly_function_t)> >
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7> function_type;
|
||||
typedef typename function_type::result_type result_type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), true>
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7> type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), false>
|
||||
{
|
||||
typedef PolyFun type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
|
||||
: as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), is_poly_function<PolyFun>::value>
|
||||
{};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), mpl::size_t<sizeof(poly_function_t)> >
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8> function_type;
|
||||
typedef typename function_type::result_type result_type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), true>
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8> type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), false>
|
||||
{
|
||||
typedef PolyFun type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
|
||||
: as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), is_poly_function<PolyFun>::value>
|
||||
{};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), mpl::size_t<sizeof(poly_function_t)> >
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9> function_type;
|
||||
typedef typename function_type::result_type result_type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), true>
|
||||
{
|
||||
typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9> type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), false>
|
||||
{
|
||||
typedef PolyFun type;
|
||||
};
|
||||
|
||||
template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
|
||||
: as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), is_poly_function<PolyFun>::value>
|
||||
{};
|
||||
67
test/external/boost/proto/detail/preprocessed/template_arity_helper.hpp
vendored
Normal file
67
test/external/boost/proto/detail/preprocessed/template_arity_helper.hpp
vendored
Normal file
@@ -0,0 +1,67 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// template_arity_helper.hpp
|
||||
// Overloads of template_arity_helper, used by the template_arity\<\> class template
|
||||
//
|
||||
// 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)
|
||||
template<
|
||||
template<typename P0> class F
|
||||
, typename T0
|
||||
>
|
||||
sized_type<2>::type
|
||||
template_arity_helper(F<T0> **, mpl::int_<1> *);
|
||||
template<
|
||||
template<typename P0 , typename P1> class F
|
||||
, typename T0 , typename T1
|
||||
>
|
||||
sized_type<3>::type
|
||||
template_arity_helper(F<T0 , T1> **, mpl::int_<2> *);
|
||||
template<
|
||||
template<typename P0 , typename P1 , typename P2> class F
|
||||
, typename T0 , typename T1 , typename T2
|
||||
>
|
||||
sized_type<4>::type
|
||||
template_arity_helper(F<T0 , T1 , T2> **, mpl::int_<3> *);
|
||||
template<
|
||||
template<typename P0 , typename P1 , typename P2 , typename P3> class F
|
||||
, typename T0 , typename T1 , typename T2 , typename T3
|
||||
>
|
||||
sized_type<5>::type
|
||||
template_arity_helper(F<T0 , T1 , T2 , T3> **, mpl::int_<4> *);
|
||||
template<
|
||||
template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4> class F
|
||||
, typename T0 , typename T1 , typename T2 , typename T3 , typename T4
|
||||
>
|
||||
sized_type<6>::type
|
||||
template_arity_helper(F<T0 , T1 , T2 , T3 , T4> **, mpl::int_<5> *);
|
||||
template<
|
||||
template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5> class F
|
||||
, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
|
||||
>
|
||||
sized_type<7>::type
|
||||
template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5> **, mpl::int_<6> *);
|
||||
template<
|
||||
template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6> class F
|
||||
, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
|
||||
>
|
||||
sized_type<8>::type
|
||||
template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6> **, mpl::int_<7> *);
|
||||
template<
|
||||
template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7> class F
|
||||
, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
|
||||
>
|
||||
sized_type<9>::type
|
||||
template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> **, mpl::int_<8> *);
|
||||
template<
|
||||
template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8> class F
|
||||
, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
|
||||
>
|
||||
sized_type<10>::type
|
||||
template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> **, mpl::int_<9> *);
|
||||
template<
|
||||
template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8 , typename P9> class F
|
||||
, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
|
||||
>
|
||||
sized_type<11>::type
|
||||
template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> **, mpl::int_<10> *);
|
||||
1464
test/external/boost/proto/detail/preprocessed/traits.hpp
vendored
Normal file
1464
test/external/boost/proto/detail/preprocessed/traits.hpp
vendored
Normal file
File diff suppressed because it is too large
Load Diff
445
test/external/boost/proto/detail/preprocessed/unpack_expr_.hpp
vendored
Normal file
445
test/external/boost/proto/detail/preprocessed/unpack_expr_.hpp
vendored
Normal file
@@ -0,0 +1,445 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file make_expr_.hpp
|
||||
/// Contains definition of make_expr_\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
template<typename Tag, typename Domain, typename Sequence, std::size_t Size>
|
||||
struct unpack_expr_
|
||||
{};
|
||||
template<typename Domain, typename Sequence>
|
||||
struct unpack_expr_<tag::terminal, Domain, Sequence, 1u>
|
||||
{
|
||||
typedef
|
||||
typename add_const<
|
||||
typename fusion::result_of::value_of<
|
||||
typename fusion::result_of::begin<Sequence>::type
|
||||
>::type
|
||||
>::type
|
||||
terminal_type;
|
||||
typedef
|
||||
typename proto::detail::protoify<
|
||||
terminal_type
|
||||
, Domain
|
||||
>::result_type
|
||||
type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
return proto::detail::protoify<terminal_type, Domain>()(fusion::at_c<0>(sequence));
|
||||
}
|
||||
};
|
||||
template<typename Sequence>
|
||||
struct unpack_expr_<tag::terminal, deduce_domain, Sequence, 1u>
|
||||
: unpack_expr_<tag::terminal, default_domain, Sequence, 1u>
|
||||
{};
|
||||
template<typename Tag, typename Domain, typename Sequence>
|
||||
struct unpack_expr_<Tag, Domain, Sequence, 1>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0;
|
||||
typedef
|
||||
list1<
|
||||
typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
fusion_iterator0 it0 = fusion::begin(sequence);
|
||||
expr_type const that = {
|
||||
detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Sequence>
|
||||
struct unpack_expr_<Tag, deduce_domain, Sequence, 1>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0;
|
||||
typedef
|
||||
unpack_expr_<
|
||||
Tag
|
||||
, typename deduce_domain1<
|
||||
typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type
|
||||
>::type
|
||||
, Sequence
|
||||
, 1
|
||||
>
|
||||
other;
|
||||
typedef typename other::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
return other::call(sequence);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Domain, typename Sequence>
|
||||
struct unpack_expr_<Tag, Domain, Sequence, 2>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1;
|
||||
typedef
|
||||
list2<
|
||||
typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0);
|
||||
expr_type const that = {
|
||||
detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Sequence>
|
||||
struct unpack_expr_<Tag, deduce_domain, Sequence, 2>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1;
|
||||
typedef
|
||||
unpack_expr_<
|
||||
Tag
|
||||
, typename deduce_domain2<
|
||||
typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type
|
||||
>::type
|
||||
, Sequence
|
||||
, 2
|
||||
>
|
||||
other;
|
||||
typedef typename other::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
return other::call(sequence);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Domain, typename Sequence>
|
||||
struct unpack_expr_<Tag, Domain, Sequence, 3>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2;
|
||||
typedef
|
||||
list3<
|
||||
typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1);
|
||||
expr_type const that = {
|
||||
detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Sequence>
|
||||
struct unpack_expr_<Tag, deduce_domain, Sequence, 3>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2;
|
||||
typedef
|
||||
unpack_expr_<
|
||||
Tag
|
||||
, typename deduce_domain3<
|
||||
typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type
|
||||
>::type
|
||||
, Sequence
|
||||
, 3
|
||||
>
|
||||
other;
|
||||
typedef typename other::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
return other::call(sequence);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Domain, typename Sequence>
|
||||
struct unpack_expr_<Tag, Domain, Sequence, 4>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3;
|
||||
typedef
|
||||
list4<
|
||||
typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2);
|
||||
expr_type const that = {
|
||||
detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Sequence>
|
||||
struct unpack_expr_<Tag, deduce_domain, Sequence, 4>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3;
|
||||
typedef
|
||||
unpack_expr_<
|
||||
Tag
|
||||
, typename deduce_domain4<
|
||||
typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type
|
||||
>::type
|
||||
, Sequence
|
||||
, 4
|
||||
>
|
||||
other;
|
||||
typedef typename other::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
return other::call(sequence);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Domain, typename Sequence>
|
||||
struct unpack_expr_<Tag, Domain, Sequence, 5>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4;
|
||||
typedef
|
||||
list5<
|
||||
typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3);
|
||||
expr_type const that = {
|
||||
detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Sequence>
|
||||
struct unpack_expr_<Tag, deduce_domain, Sequence, 5>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4;
|
||||
typedef
|
||||
unpack_expr_<
|
||||
Tag
|
||||
, typename deduce_domain5<
|
||||
typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type
|
||||
>::type
|
||||
, Sequence
|
||||
, 5
|
||||
>
|
||||
other;
|
||||
typedef typename other::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
return other::call(sequence);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Domain, typename Sequence>
|
||||
struct unpack_expr_<Tag, Domain, Sequence, 6>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5;
|
||||
typedef
|
||||
list6<
|
||||
typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4);
|
||||
expr_type const that = {
|
||||
detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Sequence>
|
||||
struct unpack_expr_<Tag, deduce_domain, Sequence, 6>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5;
|
||||
typedef
|
||||
unpack_expr_<
|
||||
Tag
|
||||
, typename deduce_domain6<
|
||||
typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type
|
||||
>::type
|
||||
, Sequence
|
||||
, 6
|
||||
>
|
||||
other;
|
||||
typedef typename other::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
return other::call(sequence);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Domain, typename Sequence>
|
||||
struct unpack_expr_<Tag, Domain, Sequence, 7>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6;
|
||||
typedef
|
||||
list7<
|
||||
typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5);
|
||||
expr_type const that = {
|
||||
detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Sequence>
|
||||
struct unpack_expr_<Tag, deduce_domain, Sequence, 7>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6;
|
||||
typedef
|
||||
unpack_expr_<
|
||||
Tag
|
||||
, typename deduce_domain7<
|
||||
typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type
|
||||
>::type
|
||||
, Sequence
|
||||
, 7
|
||||
>
|
||||
other;
|
||||
typedef typename other::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
return other::call(sequence);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Domain, typename Sequence>
|
||||
struct unpack_expr_<Tag, Domain, Sequence, 8>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7;
|
||||
typedef
|
||||
list8<
|
||||
typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); fusion_iterator7 it7 = fusion::next(it6);
|
||||
expr_type const that = {
|
||||
detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >()(*it7)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Sequence>
|
||||
struct unpack_expr_<Tag, deduce_domain, Sequence, 8>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7;
|
||||
typedef
|
||||
unpack_expr_<
|
||||
Tag
|
||||
, typename deduce_domain8<
|
||||
typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type
|
||||
>::type
|
||||
, Sequence
|
||||
, 8
|
||||
>
|
||||
other;
|
||||
typedef typename other::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
return other::call(sequence);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Domain, typename Sequence>
|
||||
struct unpack_expr_<Tag, Domain, Sequence, 9>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8;
|
||||
typedef
|
||||
list9<
|
||||
typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); fusion_iterator7 it7 = fusion::next(it6); fusion_iterator8 it8 = fusion::next(it7);
|
||||
expr_type const that = {
|
||||
detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >()(*it7) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >()(*it8)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Sequence>
|
||||
struct unpack_expr_<Tag, deduce_domain, Sequence, 9>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8;
|
||||
typedef
|
||||
unpack_expr_<
|
||||
Tag
|
||||
, typename deduce_domain9<
|
||||
typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type
|
||||
>::type
|
||||
, Sequence
|
||||
, 9
|
||||
>
|
||||
other;
|
||||
typedef typename other::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
return other::call(sequence);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Domain, typename Sequence>
|
||||
struct unpack_expr_<Tag, Domain, Sequence, 10>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8; typedef typename fusion::result_of::next< fusion_iterator8>::type fusion_iterator9;
|
||||
typedef
|
||||
list10<
|
||||
typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator9 >::type >::type , Domain >::result_type
|
||||
>
|
||||
proto_args;
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); fusion_iterator7 it7 = fusion::next(it6); fusion_iterator8 it8 = fusion::next(it7); fusion_iterator9 it9 = fusion::next(it8);
|
||||
expr_type const that = {
|
||||
detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >()(*it7) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >()(*it8) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator9 >::type >::type , Domain >()(*it9)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
template<typename Tag, typename Sequence>
|
||||
struct unpack_expr_<Tag, deduce_domain, Sequence, 10>
|
||||
{
|
||||
typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8; typedef typename fusion::result_of::next< fusion_iterator8>::type fusion_iterator9;
|
||||
typedef
|
||||
unpack_expr_<
|
||||
Tag
|
||||
, typename deduce_domain10<
|
||||
typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator9 >::type >::type
|
||||
>::type
|
||||
, Sequence
|
||||
, 10
|
||||
>
|
||||
other;
|
||||
typedef typename other::type type;
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
return other::call(sequence);
|
||||
}
|
||||
};
|
||||
178
test/external/boost/proto/detail/preprocessed/vararg_matches_impl.hpp
vendored
Normal file
178
test/external/boost/proto/detail/preprocessed/vararg_matches_impl.hpp
vendored
Normal file
@@ -0,0 +1,178 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file vararg_matches_impl.hpp
|
||||
/// Specializations of the vararg_matches_impl template
|
||||
//
|
||||
// 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)
|
||||
template<typename Args, typename Back, long To>
|
||||
struct vararg_matches_impl<Args, Back, 2, To>
|
||||
: and_2<
|
||||
matches_<
|
||||
typename detail::expr_traits<typename Args::child1>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::child1>::value_type::proto_grammar
|
||||
, Back
|
||||
>::value
|
||||
, vararg_matches_impl<Args, Back, 2 + 1, To>
|
||||
>
|
||||
{};
|
||||
template<typename Args, typename Back>
|
||||
struct vararg_matches_impl<Args, Back, 2, 2>
|
||||
: matches_<
|
||||
typename detail::expr_traits<typename Args::child1>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::child1>::value_type::proto_grammar
|
||||
, Back
|
||||
>
|
||||
{};
|
||||
template<typename Args, typename Back, long To>
|
||||
struct vararg_matches_impl<Args, Back, 3, To>
|
||||
: and_2<
|
||||
matches_<
|
||||
typename detail::expr_traits<typename Args::child2>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::child2>::value_type::proto_grammar
|
||||
, Back
|
||||
>::value
|
||||
, vararg_matches_impl<Args, Back, 3 + 1, To>
|
||||
>
|
||||
{};
|
||||
template<typename Args, typename Back>
|
||||
struct vararg_matches_impl<Args, Back, 3, 3>
|
||||
: matches_<
|
||||
typename detail::expr_traits<typename Args::child2>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::child2>::value_type::proto_grammar
|
||||
, Back
|
||||
>
|
||||
{};
|
||||
template<typename Args, typename Back, long To>
|
||||
struct vararg_matches_impl<Args, Back, 4, To>
|
||||
: and_2<
|
||||
matches_<
|
||||
typename detail::expr_traits<typename Args::child3>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::child3>::value_type::proto_grammar
|
||||
, Back
|
||||
>::value
|
||||
, vararg_matches_impl<Args, Back, 4 + 1, To>
|
||||
>
|
||||
{};
|
||||
template<typename Args, typename Back>
|
||||
struct vararg_matches_impl<Args, Back, 4, 4>
|
||||
: matches_<
|
||||
typename detail::expr_traits<typename Args::child3>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::child3>::value_type::proto_grammar
|
||||
, Back
|
||||
>
|
||||
{};
|
||||
template<typename Args, typename Back, long To>
|
||||
struct vararg_matches_impl<Args, Back, 5, To>
|
||||
: and_2<
|
||||
matches_<
|
||||
typename detail::expr_traits<typename Args::child4>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::child4>::value_type::proto_grammar
|
||||
, Back
|
||||
>::value
|
||||
, vararg_matches_impl<Args, Back, 5 + 1, To>
|
||||
>
|
||||
{};
|
||||
template<typename Args, typename Back>
|
||||
struct vararg_matches_impl<Args, Back, 5, 5>
|
||||
: matches_<
|
||||
typename detail::expr_traits<typename Args::child4>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::child4>::value_type::proto_grammar
|
||||
, Back
|
||||
>
|
||||
{};
|
||||
template<typename Args, typename Back, long To>
|
||||
struct vararg_matches_impl<Args, Back, 6, To>
|
||||
: and_2<
|
||||
matches_<
|
||||
typename detail::expr_traits<typename Args::child5>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::child5>::value_type::proto_grammar
|
||||
, Back
|
||||
>::value
|
||||
, vararg_matches_impl<Args, Back, 6 + 1, To>
|
||||
>
|
||||
{};
|
||||
template<typename Args, typename Back>
|
||||
struct vararg_matches_impl<Args, Back, 6, 6>
|
||||
: matches_<
|
||||
typename detail::expr_traits<typename Args::child5>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::child5>::value_type::proto_grammar
|
||||
, Back
|
||||
>
|
||||
{};
|
||||
template<typename Args, typename Back, long To>
|
||||
struct vararg_matches_impl<Args, Back, 7, To>
|
||||
: and_2<
|
||||
matches_<
|
||||
typename detail::expr_traits<typename Args::child6>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::child6>::value_type::proto_grammar
|
||||
, Back
|
||||
>::value
|
||||
, vararg_matches_impl<Args, Back, 7 + 1, To>
|
||||
>
|
||||
{};
|
||||
template<typename Args, typename Back>
|
||||
struct vararg_matches_impl<Args, Back, 7, 7>
|
||||
: matches_<
|
||||
typename detail::expr_traits<typename Args::child6>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::child6>::value_type::proto_grammar
|
||||
, Back
|
||||
>
|
||||
{};
|
||||
template<typename Args, typename Back, long To>
|
||||
struct vararg_matches_impl<Args, Back, 8, To>
|
||||
: and_2<
|
||||
matches_<
|
||||
typename detail::expr_traits<typename Args::child7>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::child7>::value_type::proto_grammar
|
||||
, Back
|
||||
>::value
|
||||
, vararg_matches_impl<Args, Back, 8 + 1, To>
|
||||
>
|
||||
{};
|
||||
template<typename Args, typename Back>
|
||||
struct vararg_matches_impl<Args, Back, 8, 8>
|
||||
: matches_<
|
||||
typename detail::expr_traits<typename Args::child7>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::child7>::value_type::proto_grammar
|
||||
, Back
|
||||
>
|
||||
{};
|
||||
template<typename Args, typename Back, long To>
|
||||
struct vararg_matches_impl<Args, Back, 9, To>
|
||||
: and_2<
|
||||
matches_<
|
||||
typename detail::expr_traits<typename Args::child8>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::child8>::value_type::proto_grammar
|
||||
, Back
|
||||
>::value
|
||||
, vararg_matches_impl<Args, Back, 9 + 1, To>
|
||||
>
|
||||
{};
|
||||
template<typename Args, typename Back>
|
||||
struct vararg_matches_impl<Args, Back, 9, 9>
|
||||
: matches_<
|
||||
typename detail::expr_traits<typename Args::child8>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::child8>::value_type::proto_grammar
|
||||
, Back
|
||||
>
|
||||
{};
|
||||
template<typename Args, typename Back, long To>
|
||||
struct vararg_matches_impl<Args, Back, 10, To>
|
||||
: and_2<
|
||||
matches_<
|
||||
typename detail::expr_traits<typename Args::child9>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::child9>::value_type::proto_grammar
|
||||
, Back
|
||||
>::value
|
||||
, vararg_matches_impl<Args, Back, 10 + 1, To>
|
||||
>
|
||||
{};
|
||||
template<typename Args, typename Back>
|
||||
struct vararg_matches_impl<Args, Back, 10, 10>
|
||||
: matches_<
|
||||
typename detail::expr_traits<typename Args::child9>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::child9>::value_type::proto_grammar
|
||||
, Back
|
||||
>
|
||||
{};
|
||||
82
test/external/boost/proto/detail/remove_typename.hpp
vendored
Normal file
82
test/external/boost/proto/detail/remove_typename.hpp
vendored
Normal file
@@ -0,0 +1,82 @@
|
||||
//==============================================================================
|
||||
// Copyright 2003 - 2011 LASMEA UMR 6602 CNRS/Univ. Clermont II
|
||||
// Copyright 2009 - 2011 LRI UMR 8623 CNRS/Univ Paris Sud XI
|
||||
// Copyright 2011 Eric Niebler
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// See accompanying file LICENSE.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt
|
||||
//==============================================================================
|
||||
#ifndef BOOST_PROTO_PREPROCESSOR_REMOVE_TYPENAME_HPP_INCLUDED
|
||||
#define BOOST_PROTO_PREPROCESSOR_REMOVE_TYPENAME_HPP_INCLUDED
|
||||
|
||||
/*!
|
||||
* \file
|
||||
* \brief Defines the BOOST_PROTO_REMOVE_TYPENAME macro
|
||||
*/
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/expand.hpp>
|
||||
#include <boost/preprocessor/tuple/eat.hpp>
|
||||
#include <boost/preprocessor/control/iif.hpp>
|
||||
#include <boost/preprocessor/detail/is_unary.hpp>
|
||||
|
||||
//==============================================================================
|
||||
// Boost.Preprocessor author P. Mensodines confirmed on an Boost email thread
|
||||
// (subject ``check if a token is a keyword (was "BOOST_PP_IS_UNARY()")'')
|
||||
// that it is OK to used `PP_IS_UNARY()` to check if tokens match predefined
|
||||
// "keyword" as it is done by the macros below (even if `PP_IS_UNARY()` is
|
||||
// technically only part of Boost.Preprocessor private API).
|
||||
//==============================================================================
|
||||
|
||||
//==============================================================================
|
||||
// `checking_prefix ## tokens` expand to unary (e.g., `(1)`) iff `tokens` start
|
||||
// with keyword to check.
|
||||
//==============================================================================
|
||||
#define BOOST_PROTO_DETAILS_KEYWORD_FACILITY_IS_FRONT(T, CHECKING_PREFIX) \
|
||||
BOOST_PP_IS_UNARY(BOOST_PP_CAT(CHECKING_PREFIX, T)) \
|
||||
/**/
|
||||
|
||||
//==============================================================================
|
||||
// `is_front_macro(tokens)` is 1 iff `tokens` start with keyword to remove.
|
||||
// `removing_prefix ## <keyword-to-remove>` must expand to nothing.
|
||||
//==============================================================================
|
||||
#define BOOST_PROTO_DETAILS_KEYWORD_FACILITY_REMOVE_FRONT(TOKENS, IS_FRONT_MACRO, REMOVING_PREFIX) \
|
||||
BOOST_PP_EXPAND( /* without EXPAND doesn't expand on MSVC */ \
|
||||
BOOST_PP_IIF( \
|
||||
IS_FRONT_MACRO(TOKENS) \
|
||||
, BOOST_PP_CAT \
|
||||
, TOKENS BOOST_PP_TUPLE_EAT(2) \
|
||||
)(REMOVING_PREFIX, TOKENS) \
|
||||
) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_IS_typename (1) /* unary */
|
||||
#define typename_BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_IS (1) /* unary */
|
||||
#define BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_REMOVE_typename /* nothing */
|
||||
#define typename_BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_REMOVE /* nothing */
|
||||
|
||||
#define BOOST_PROTO_DETAILS_KEYWORD_IS_TYPENAME_FRONT(TOKENS) \
|
||||
BOOST_PROTO_DETAILS_KEYWORD_FACILITY_IS_FRONT(TOKENS, BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_IS_) \
|
||||
/**/
|
||||
|
||||
//==============================================================================
|
||||
/*!
|
||||
* \ingroup preprocessor
|
||||
* For any symbol \c X, this macro returns the same symbol from which a potential
|
||||
* leading \c typename keyword has been removed. If no typename keyword is present,
|
||||
* this macros evaluates to \c X itself without error.
|
||||
*
|
||||
* The original implementation of this macro is from Lorenzo Caminiti.
|
||||
*
|
||||
* \param X Symbol to remove \c typename from
|
||||
*/
|
||||
//==============================================================================
|
||||
#define BOOST_PROTO_REMOVE_TYPENAME(X) \
|
||||
BOOST_PROTO_DETAILS_KEYWORD_FACILITY_REMOVE_FRONT( \
|
||||
X \
|
||||
, BOOST_PROTO_DETAILS_KEYWORD_IS_TYPENAME_FRONT \
|
||||
, BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_REMOVE_ \
|
||||
) \
|
||||
/**/
|
||||
|
||||
#endif
|
||||
189
test/external/boost/proto/detail/reverse.hpp
vendored
Normal file
189
test/external/boost/proto/detail/reverse.hpp
vendored
Normal file
@@ -0,0 +1,189 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2006 Joel de Guzman
|
||||
Copyright (c) 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_DETAIL_FUSION_REVERSE_EAH_01_22_2008
|
||||
#define BOOST_PROTO_DETAIL_FUSION_REVERSE_EAH_01_22_2008
|
||||
|
||||
#include <boost/spirit/fusion/detail/access.hpp>
|
||||
#include <boost/spirit/fusion/iterator/as_fusion_iterator.hpp>
|
||||
#include <boost/spirit/fusion/iterator/detail/iterator_base.hpp>
|
||||
#include <boost/spirit/fusion/sequence/detail/sequence_base.hpp>
|
||||
#include <boost/spirit/fusion/iterator/next.hpp>
|
||||
#include <boost/spirit/fusion/iterator/prior.hpp>
|
||||
#include <boost/spirit/fusion/iterator/deref.hpp>
|
||||
#include <boost/spirit/fusion/iterator/value_of.hpp>
|
||||
#include <boost/spirit/fusion/sequence/begin.hpp>
|
||||
#include <boost/spirit/fusion/sequence/end.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
struct reverse_view_tag;
|
||||
struct reverse_view_iterator_tag;
|
||||
|
||||
template <typename First>
|
||||
struct reverse_view_iterator
|
||||
: iterator_base<reverse_view_iterator<First> >
|
||||
{
|
||||
typedef as_fusion_iterator<First> converter;
|
||||
typedef typename converter::type first_type;
|
||||
typedef reverse_view_iterator_tag tag;
|
||||
|
||||
reverse_view_iterator(First const& first)
|
||||
: first(converter::convert(first)) {}
|
||||
|
||||
first_type first;
|
||||
};
|
||||
|
||||
template <typename Sequence>
|
||||
struct reverse_view : sequence_base<reverse_view<Sequence> >
|
||||
{
|
||||
typedef as_fusion_sequence<Sequence> seq_converter;
|
||||
typedef typename seq_converter::type seq;
|
||||
|
||||
typedef reverse_view_tag tag;
|
||||
typedef typename meta::begin<seq>::type first_type;
|
||||
typedef typename meta::end<seq>::type last_type;
|
||||
|
||||
reverse_view(Sequence& seq)
|
||||
: first(fusion::begin(seq))
|
||||
, last(fusion::end(seq))
|
||||
{}
|
||||
|
||||
first_type first;
|
||||
last_type last;
|
||||
};
|
||||
|
||||
namespace meta
|
||||
{
|
||||
template <>
|
||||
struct deref_impl<reverse_view_iterator_tag>
|
||||
{
|
||||
template <typename Iterator>
|
||||
struct apply
|
||||
{
|
||||
typedef typename
|
||||
meta::deref<
|
||||
typename meta::prior<
|
||||
typename Iterator::first_type
|
||||
>::type
|
||||
>::type
|
||||
type;
|
||||
|
||||
static type
|
||||
call(Iterator const& i)
|
||||
{
|
||||
return *fusion::prior(i.first);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct prior_impl<reverse_view_iterator_tag>
|
||||
{
|
||||
template <typename Iterator>
|
||||
struct apply
|
||||
{
|
||||
typedef typename Iterator::first_type first_type;
|
||||
typedef typename next_impl<typename first_type::tag>::
|
||||
template apply<first_type>
|
||||
wrapped;
|
||||
|
||||
typedef reverse_view_iterator<typename wrapped::type> type;
|
||||
|
||||
static type
|
||||
call(Iterator const& i)
|
||||
{
|
||||
return type(wrapped::call(i.first));
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct next_impl<reverse_view_iterator_tag>
|
||||
{
|
||||
template <typename Iterator>
|
||||
struct apply
|
||||
{
|
||||
typedef typename Iterator::first_type first_type;
|
||||
typedef typename prior_impl<typename first_type::tag>::
|
||||
template apply<first_type>
|
||||
wrapped;
|
||||
|
||||
typedef reverse_view_iterator<typename wrapped::type> type;
|
||||
|
||||
static type
|
||||
call(Iterator const& i)
|
||||
{
|
||||
return type(wrapped::call(i.first));
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct value_impl<reverse_view_iterator_tag>
|
||||
{
|
||||
template <typename Iterator>
|
||||
struct apply
|
||||
{
|
||||
typedef typename
|
||||
meta::value_of<
|
||||
typename meta::prior<
|
||||
typename Iterator::first_type
|
||||
>::type
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct begin_impl<reverse_view_tag>
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct apply
|
||||
{
|
||||
typedef reverse_view_iterator<typename Sequence::last_type> type;
|
||||
|
||||
static type
|
||||
call(Sequence const& s)
|
||||
{
|
||||
return type(s.last);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct end_impl<reverse_view_tag>
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct apply
|
||||
{
|
||||
typedef reverse_view_iterator<typename Sequence::first_type> type;
|
||||
|
||||
static type
|
||||
call(Sequence const& s)
|
||||
{
|
||||
return type(s.first);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template <typename Sequence>
|
||||
struct reverse
|
||||
{
|
||||
typedef reverse_view<Sequence> type;
|
||||
};
|
||||
}
|
||||
|
||||
template <typename Sequence>
|
||||
inline reverse_view<Sequence const>
|
||||
reverse(Sequence const& view)
|
||||
{
|
||||
return reverse_view<Sequence const>(view);
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
67
test/external/boost/proto/detail/template_arity.hpp
vendored
Normal file
67
test/external/boost/proto/detail/template_arity.hpp
vendored
Normal file
@@ -0,0 +1,67 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file template_arity.hpp
|
||||
/// Replace all nodes stored by reference by nodes stored by value.
|
||||
//
|
||||
// Copyright 2011 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)
|
||||
//
|
||||
// This file is based on a similar one in MPL from Aleksey Gurtovoy.
|
||||
|
||||
#ifndef BOOST_PROTO_DETAIL_TEMPLATE_ARITY_HPP_EAN_2011_05_07
|
||||
#define BOOST_PROTO_DETAIL_TEMPLATE_ARITY_HPP_EAN_2011_05_07
|
||||
|
||||
// Somewhat indirect definition of BOOST_PROTO_TEMPLATE_ARITY_PARAM is
|
||||
// to overcome a shortcoming of the Wave tool used to generate the
|
||||
// pre-preprocessed headers.
|
||||
#define BOOST_PROTO_TEMPLATE_ARITY_PARAM BOOST_PROTO_TEMPLATE_ARITY_PARAM2
|
||||
#define BOOST_PROTO_TEMPLATE_ARITY_PARAM2(param)
|
||||
|
||||
#if defined(BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) || \
|
||||
(defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES))
|
||||
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/inc.hpp>
|
||||
#include <boost/preprocessor/iteration/iterate.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/mpl/int.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
|
||||
#undef BOOST_PROTO_TEMPLATE_ARITY_PARAM2
|
||||
#define BOOST_PROTO_TEMPLATE_ARITY_PARAM2(param) , param
|
||||
|
||||
namespace boost { namespace proto { namespace detail
|
||||
{
|
||||
sized_type<1>::type template_arity_helper(...);
|
||||
|
||||
// Other overloads generated by the preprocessor
|
||||
#include <boost/proto/detail/template_arity_helper.hpp>
|
||||
|
||||
template<typename F, int N, int Size>
|
||||
struct template_arity_impl2
|
||||
: mpl::int_<Size - 1>
|
||||
{};
|
||||
|
||||
template<typename F, int N = BOOST_PROTO_MAX_ARITY>
|
||||
struct template_arity
|
||||
: template_arity_impl2<
|
||||
F
|
||||
, N
|
||||
, sizeof(detail::template_arity_helper((F **)0, (mpl::int_<N> *)0))
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename F, int N>
|
||||
struct template_arity_impl2<F, N, 1>
|
||||
: template_arity<F, N-1>
|
||||
{};
|
||||
|
||||
template<typename F>
|
||||
struct template_arity_impl2<F, 0, 1>
|
||||
: mpl::int_<-1>
|
||||
{};
|
||||
|
||||
}}}
|
||||
|
||||
#endif // BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING
|
||||
#endif // BOOST_PROTO_DETAIL_TEMPLATE_ARITY_HPP_EAN_2011_05_07
|
||||
44
test/external/boost/proto/detail/template_arity_helper.hpp
vendored
Normal file
44
test/external/boost/proto/detail/template_arity_helper.hpp
vendored
Normal file
@@ -0,0 +1,44 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/template_arity_helper.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/template_arity_helper.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// template_arity_helper.hpp
|
||||
// Overloads of template_arity_helper, used by the template_arity\<\> class template
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/template_arity_helper.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
template<
|
||||
template<BOOST_PP_ENUM_PARAMS(N, typename P)> class F
|
||||
, BOOST_PP_ENUM_PARAMS(N, typename T)
|
||||
>
|
||||
sized_type<BOOST_PP_INC(N)>::type
|
||||
template_arity_helper(F<BOOST_PP_ENUM_PARAMS(N, T)> **, mpl::int_<N> *);
|
||||
|
||||
#undef N
|
||||
|
||||
#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES
|
||||
219
test/external/boost/proto/detail/traits.hpp
vendored
Normal file
219
test/external/boost/proto/detail/traits.hpp
vendored
Normal file
@@ -0,0 +1,219 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/traits.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#define BOOST_PROTO_CHILD(Z, N, DATA) \
|
||||
/** INTERNAL ONLY */ \
|
||||
typedef BOOST_PP_CAT(DATA, N) BOOST_PP_CAT(proto_child, N); \
|
||||
/**/
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/traits.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file traits.hpp
|
||||
/// Definitions of proto::function, proto::nary_expr and proto::result_of::child_c
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/traits.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#undef BOOST_PROTO_CHILD
|
||||
|
||||
#else // BOOST_PP_IS_ITERATING
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
#if N > 0
|
||||
/// \brief A metafunction for generating function-call expression types,
|
||||
/// a grammar element for matching function-call expressions, and a
|
||||
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
|
||||
/// transform.
|
||||
template<BOOST_PP_ENUM_PARAMS(N, typename A)>
|
||||
struct function
|
||||
#if N != BOOST_PROTO_MAX_ARITY
|
||||
<
|
||||
BOOST_PP_ENUM_PARAMS(N, A)
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT)
|
||||
>
|
||||
#endif
|
||||
: proto::transform<
|
||||
function<
|
||||
BOOST_PP_ENUM_PARAMS(N, A)
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT)
|
||||
>
|
||||
, int
|
||||
>
|
||||
{
|
||||
typedef proto::expr<proto::tag::function, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> type;
|
||||
typedef proto::basic_expr<proto::tag::function, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> proto_grammar;
|
||||
|
||||
template<typename Expr, typename State, typename Data>
|
||||
struct impl
|
||||
: detail::pass_through_impl<function, Expr, State, Data>
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
typedef proto::tag::function proto_tag;
|
||||
BOOST_PP_REPEAT(N, BOOST_PROTO_CHILD, A)
|
||||
BOOST_PP_REPEAT_FROM_TO(
|
||||
N
|
||||
, BOOST_PROTO_MAX_ARITY
|
||||
, BOOST_PROTO_CHILD
|
||||
, detail::if_vararg<BOOST_PP_CAT(A, BOOST_PP_DEC(N))> BOOST_PP_INTERCEPT
|
||||
)
|
||||
};
|
||||
|
||||
/// \brief A metafunction for generating n-ary expression types with a
|
||||
/// specified tag type,
|
||||
/// a grammar element for matching n-ary expressions, and a
|
||||
/// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
|
||||
/// transform.
|
||||
///
|
||||
/// Use <tt>nary_expr\<_, vararg\<_\> \></tt> as a grammar element to match any
|
||||
/// n-ary expression; that is, any non-terminal.
|
||||
template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
|
||||
struct nary_expr
|
||||
#if N != BOOST_PROTO_MAX_ARITY
|
||||
<
|
||||
Tag
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT)
|
||||
>
|
||||
#endif
|
||||
: proto::transform<
|
||||
nary_expr<
|
||||
Tag
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT)
|
||||
>
|
||||
, int
|
||||
>
|
||||
{
|
||||
typedef proto::expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> type;
|
||||
typedef proto::basic_expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> proto_grammar;
|
||||
|
||||
template<typename Expr, typename State, typename Data>
|
||||
struct impl
|
||||
: detail::pass_through_impl<nary_expr, Expr, State, Data>
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
typedef Tag proto_tag;
|
||||
BOOST_PP_REPEAT(N, BOOST_PROTO_CHILD, A)
|
||||
BOOST_PP_REPEAT_FROM_TO(
|
||||
N
|
||||
, BOOST_PROTO_MAX_ARITY
|
||||
, BOOST_PROTO_CHILD
|
||||
, detail::if_vararg<BOOST_PP_CAT(A, BOOST_PP_DEC(N))> BOOST_PP_INTERCEPT
|
||||
)
|
||||
};
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template<
|
||||
template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class T
|
||||
, BOOST_PP_ENUM_PARAMS(N, typename A)
|
||||
>
|
||||
struct is_callable_<T<BOOST_PP_ENUM_PARAMS(N, A)> BOOST_PROTO_TEMPLATE_ARITY_PARAM(N)>
|
||||
: is_same<BOOST_PP_CAT(A, BOOST_PP_DEC(N)), callable>
|
||||
{};
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
/// \brief A metafunction that returns the type of the Nth child
|
||||
/// of a Proto expression.
|
||||
///
|
||||
/// A metafunction that returns the type of the Nth child
|
||||
/// of a Proto expression. \c N must be less than
|
||||
/// \c Expr::proto_arity::value.
|
||||
template<typename Expr>
|
||||
struct child_c<Expr, N>
|
||||
{
|
||||
/// Verify that we are not operating on a terminal
|
||||
BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
|
||||
|
||||
/// The raw type of the Nth child as it is stored within
|
||||
/// \c Expr. This may be a value or a reference
|
||||
typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type;
|
||||
|
||||
/// The "value" type of the child, suitable for return by value,
|
||||
/// computed as follows:
|
||||
/// \li <tt>T const &</tt> becomes <tt>T</tt>
|
||||
/// \li <tt>T &</tt> becomes <tt>T</tt>
|
||||
/// \li <tt>T</tt> becomes <tt>T</tt>
|
||||
typedef typename detail::expr_traits<typename Expr::BOOST_PP_CAT(proto_child, N)>::value_type type;
|
||||
};
|
||||
|
||||
template<typename Expr>
|
||||
struct child_c<Expr &, N>
|
||||
{
|
||||
/// Verify that we are not operating on a terminal
|
||||
BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
|
||||
|
||||
/// The raw type of the Nth child as it is stored within
|
||||
/// \c Expr. This may be a value or a reference
|
||||
typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type;
|
||||
|
||||
/// The "reference" type of the child, suitable for return by
|
||||
/// reference, computed as follows:
|
||||
/// \li <tt>T const &</tt> becomes <tt>T const &</tt>
|
||||
/// \li <tt>T &</tt> becomes <tt>T &</tt>
|
||||
/// \li <tt>T</tt> becomes <tt>T &</tt>
|
||||
typedef typename detail::expr_traits<typename Expr::BOOST_PP_CAT(proto_child, N)>::reference type;
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
static type call(Expr &e)
|
||||
{
|
||||
return e.proto_base().BOOST_PP_CAT(child, N);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Expr>
|
||||
struct child_c<Expr const &, N>
|
||||
{
|
||||
/// Verify that we are not operating on a terminal
|
||||
BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
|
||||
|
||||
/// The raw type of the Nth child as it is stored within
|
||||
/// \c Expr. This may be a value or a reference
|
||||
typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type;
|
||||
|
||||
/// The "const reference" type of the child, suitable for return by
|
||||
/// const reference, computed as follows:
|
||||
/// \li <tt>T const &</tt> becomes <tt>T const &</tt>
|
||||
/// \li <tt>T &</tt> becomes <tt>T &</tt>
|
||||
/// \li <tt>T</tt> becomes <tt>T const &</tt>
|
||||
typedef typename detail::expr_traits<typename Expr::BOOST_PP_CAT(proto_child, N)>::const_reference type;
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
static type call(Expr const &e)
|
||||
{
|
||||
return e.proto_base().BOOST_PP_CAT(child, N);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#undef N
|
||||
|
||||
#endif
|
||||
195
test/external/boost/proto/detail/unpack_expr_.hpp
vendored
Normal file
195
test/external/boost/proto/detail/unpack_expr_.hpp
vendored
Normal file
@@ -0,0 +1,195 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/unpack_expr_.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE(Z, N, DATA) \
|
||||
typedef typename fusion::result_of::next< \
|
||||
BOOST_PP_CAT(fusion_iterator, N)>::type \
|
||||
BOOST_PP_CAT(fusion_iterator, BOOST_PP_INC(N)); \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_FUSION_ITERATORS_TYPE(N) \
|
||||
typedef \
|
||||
typename fusion::result_of::begin<Sequence const>::type \
|
||||
fusion_iterator0; \
|
||||
BOOST_PP_REPEAT(BOOST_PP_DEC(N), BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE, fusion_iterator) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA) \
|
||||
typename add_const< \
|
||||
typename fusion::result_of::value_of< \
|
||||
BOOST_PP_CAT(fusion_iterator, N) \
|
||||
>::type \
|
||||
>::type \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_FUSION_NEXT_ITERATOR(Z, N, DATA) \
|
||||
BOOST_PP_CAT(fusion_iterator, BOOST_PP_INC(N)) BOOST_PP_CAT(it, BOOST_PP_INC(N)) = \
|
||||
fusion::next(BOOST_PP_CAT(it, N)); \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_FUSION_ITERATORS(N) \
|
||||
fusion_iterator0 it0 = fusion::begin(sequence); \
|
||||
BOOST_PP_REPEAT(BOOST_PP_DEC(N), BOOST_PROTO_FUSION_NEXT_ITERATOR, fusion_iterator) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_FUSION_AT(Z, N, DATA) \
|
||||
*BOOST_PP_CAT(it, N) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_FUSION_AS_CHILD_AT_TYPE(Z, N, DATA) \
|
||||
typename detail::protoify< \
|
||||
BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA) \
|
||||
, Domain \
|
||||
>::result_type \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_FUSION_AS_CHILD_AT(Z, N, DATA) \
|
||||
detail::protoify< \
|
||||
BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA) \
|
||||
, Domain \
|
||||
>()(BOOST_PROTO_FUSION_AT(Z, N, DATA)) \
|
||||
/**/
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/unpack_expr_.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file make_expr_.hpp
|
||||
/// Contains definition of make_expr_\<\> class template.
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
template<typename Tag, typename Domain, typename Sequence, std::size_t Size>
|
||||
struct unpack_expr_
|
||||
{};
|
||||
|
||||
template<typename Domain, typename Sequence>
|
||||
struct unpack_expr_<tag::terminal, Domain, Sequence, 1u>
|
||||
{
|
||||
typedef
|
||||
typename add_const<
|
||||
typename fusion::result_of::value_of<
|
||||
typename fusion::result_of::begin<Sequence>::type
|
||||
>::type
|
||||
>::type
|
||||
terminal_type;
|
||||
|
||||
typedef
|
||||
typename proto::detail::protoify<
|
||||
terminal_type
|
||||
, Domain
|
||||
>::result_type
|
||||
type;
|
||||
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
return proto::detail::protoify<terminal_type, Domain>()(fusion::at_c<0>(sequence));
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Sequence>
|
||||
struct unpack_expr_<tag::terminal, deduce_domain, Sequence, 1u>
|
||||
: unpack_expr_<tag::terminal, default_domain, Sequence, 1u>
|
||||
{};
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/unpack_expr_.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#undef BOOST_PROTO_FUSION_AT
|
||||
#undef BOOST_PROTO_FUSION_AT_TYPE
|
||||
#undef BOOST_PROTO_FUSION_AS_CHILD_AT
|
||||
#undef BOOST_PROTO_FUSION_AS_CHILD_AT_TYPE
|
||||
#undef BOOST_PROTO_FUSION_NEXT_ITERATOR
|
||||
#undef BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE
|
||||
#undef BOOST_PROTO_FUSION_ITERATORS
|
||||
#undef BOOST_PROTO_FUSION_ITERATORS_TYPE
|
||||
|
||||
#else // BOOST_PP_IS_ITERATING
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
#define M BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N)
|
||||
|
||||
template<typename Tag, typename Domain, typename Sequence>
|
||||
struct unpack_expr_<Tag, Domain, Sequence, N>
|
||||
{
|
||||
BOOST_PROTO_FUSION_ITERATORS_TYPE(N)
|
||||
|
||||
typedef
|
||||
BOOST_PP_CAT(list, N)<
|
||||
BOOST_PP_ENUM(N, BOOST_PROTO_FUSION_AS_CHILD_AT_TYPE, ~)
|
||||
>
|
||||
proto_args;
|
||||
|
||||
typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
|
||||
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
BOOST_PROTO_FUSION_ITERATORS(N)
|
||||
expr_type const that = {
|
||||
BOOST_PP_ENUM(N, BOOST_PROTO_FUSION_AS_CHILD_AT, ~)
|
||||
};
|
||||
return proto_generator()(that);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Tag, typename Sequence>
|
||||
struct unpack_expr_<Tag, deduce_domain, Sequence, N>
|
||||
{
|
||||
BOOST_PROTO_FUSION_ITERATORS_TYPE(N)
|
||||
|
||||
typedef
|
||||
unpack_expr_<
|
||||
Tag
|
||||
, typename BOOST_PP_CAT(deduce_domain, N)<
|
||||
BOOST_PP_ENUM(N, BOOST_PROTO_FUSION_AT_TYPE, ~)
|
||||
>::type
|
||||
, Sequence
|
||||
, N
|
||||
>
|
||||
other;
|
||||
|
||||
typedef typename other::type type;
|
||||
|
||||
static type const call(Sequence const &sequence)
|
||||
{
|
||||
return other::call(sequence);
|
||||
}
|
||||
};
|
||||
|
||||
#undef N
|
||||
#undef M
|
||||
|
||||
#endif
|
||||
58
test/external/boost/proto/detail/vararg_matches_impl.hpp
vendored
Normal file
58
test/external/boost/proto/detail/vararg_matches_impl.hpp
vendored
Normal file
@@ -0,0 +1,58 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/vararg_matches_impl.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/vararg_matches_impl.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file vararg_matches_impl.hpp
|
||||
/// Specializations of the vararg_matches_impl template
|
||||
//
|
||||
// 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)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/vararg_matches_impl.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#else // BOOST_PP_IS_ITERATING
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
template<typename Args, typename Back, long To>
|
||||
struct vararg_matches_impl<Args, Back, N, To>
|
||||
: and_2<
|
||||
matches_<
|
||||
typename detail::expr_traits<typename Args::BOOST_PP_CAT(child, BOOST_PP_DEC(N))>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::BOOST_PP_CAT(child, BOOST_PP_DEC(N))>::value_type::proto_grammar
|
||||
, Back
|
||||
>::value
|
||||
, vararg_matches_impl<Args, Back, N + 1, To>
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Args, typename Back>
|
||||
struct vararg_matches_impl<Args, Back, N, N>
|
||||
: matches_<
|
||||
typename detail::expr_traits<typename Args::BOOST_PP_CAT(child, BOOST_PP_DEC(N))>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args::BOOST_PP_CAT(child, BOOST_PP_DEC(N))>::value_type::proto_grammar
|
||||
, Back
|
||||
>
|
||||
{};
|
||||
|
||||
#undef N
|
||||
|
||||
#endif
|
||||
326
test/external/boost/proto/domain.hpp
vendored
Normal file
326
test/external/boost/proto/domain.hpp
vendored
Normal file
@@ -0,0 +1,326 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file domain.hpp
|
||||
/// Contains definition of domain\<\> class template and helpers for
|
||||
/// defining domains with a generator and a grammar for controlling
|
||||
/// operator overloading.
|
||||
//
|
||||
// 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_DOMAIN_HPP_EAN_02_13_2007
|
||||
#define BOOST_PROTO_DOMAIN_HPP_EAN_02_13_2007
|
||||
|
||||
#include <boost/ref.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/generate.hpp>
|
||||
#include <boost/proto/detail/as_expr.hpp>
|
||||
#include <boost/proto/detail/deduce_domain.hpp>
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
|
||||
namespace detail
|
||||
{
|
||||
struct not_a_generator
|
||||
{};
|
||||
|
||||
struct not_a_grammar
|
||||
{};
|
||||
|
||||
struct not_a_domain
|
||||
{};
|
||||
}
|
||||
|
||||
namespace domainns_
|
||||
{
|
||||
/// \brief For use in defining domain tags to be used
|
||||
/// with \c proto::extends\<\>. A \e Domain associates
|
||||
/// an expression type with a \e Generator, and optionally
|
||||
/// a \e Grammar.
|
||||
///
|
||||
/// The Generator determines how new expressions in the
|
||||
/// domain are constructed. Typically, a generator wraps
|
||||
/// all new expressions in a wrapper that imparts
|
||||
/// domain-specific behaviors to expressions within its
|
||||
/// domain. (See \c proto::extends\<\>.)
|
||||
///
|
||||
/// The Grammar determines whether a given expression is
|
||||
/// valid within the domain, and automatically disables
|
||||
/// any operator overloads which would cause an invalid
|
||||
/// expression to be created. By default, the Grammar
|
||||
/// parameter defaults to the wildcard, \c proto::_, which
|
||||
/// makes all expressions valid within the domain.
|
||||
///
|
||||
/// The Super declares the domain currently being defined
|
||||
/// to be a sub-domain of Super. Expressions in sub-domains
|
||||
/// can be freely combined with expressions in its super-
|
||||
/// domain (and <I>its</I> super-domain, etc.).
|
||||
///
|
||||
/// Example:
|
||||
/// \code
|
||||
/// template<typename Expr>
|
||||
/// struct MyExpr;
|
||||
///
|
||||
/// struct MyGrammar
|
||||
/// : or_< terminal<_>, plus<MyGrammar, MyGrammar> >
|
||||
/// {};
|
||||
///
|
||||
/// // Define MyDomain, in which all expressions are
|
||||
/// // wrapped in MyExpr<> and only expressions that
|
||||
/// // conform to MyGrammar are allowed.
|
||||
/// struct MyDomain
|
||||
/// : domain<generator<MyExpr>, MyGrammar>
|
||||
/// {};
|
||||
///
|
||||
/// // Use MyDomain to define MyExpr
|
||||
/// template<typename Expr>
|
||||
/// struct MyExpr
|
||||
/// : extends<Expr, MyExpr<Expr>, MyDomain>
|
||||
/// {
|
||||
/// // ...
|
||||
/// };
|
||||
/// \endcode
|
||||
///
|
||||
template<
|
||||
typename Generator // = default_generator
|
||||
, typename Grammar // = proto::_
|
||||
, typename Super // = no_super_domain
|
||||
>
|
||||
struct domain
|
||||
: Generator
|
||||
{
|
||||
typedef Generator proto_generator;
|
||||
typedef Grammar proto_grammar;
|
||||
typedef Super proto_super_domain;
|
||||
typedef domain proto_base_domain;
|
||||
|
||||
/// INTERNAL ONLY
|
||||
typedef void proto_is_domain_;
|
||||
|
||||
/// \brief A unary MonomorphicFunctionObject that turns objects into Proto
|
||||
/// expression objects in this domain.
|
||||
///
|
||||
/// The <tt>as_expr\<\></tt> function object turns objects into Proto expressions, if
|
||||
/// they are not already, by making them Proto terminals held by value if
|
||||
/// possible. Objects that are already Proto expressions are left alone.
|
||||
///
|
||||
/// If <tt>wants_basic_expr\<Generator\>::value</tt> is true, then let \c E be \c basic_expr;
|
||||
/// otherwise, let \t E be \c expr. Given an lvalue \c t of type \c T:
|
||||
///
|
||||
/// If \c T is not a Proto expression type the resulting terminal is
|
||||
/// calculated as follows:
|
||||
///
|
||||
/// If \c T is a function type, an abstract type, or a type derived from
|
||||
/// \c std::ios_base, let \c A be <tt>T &</tt>.
|
||||
/// Otherwise, let \c A be the type \c T stripped of cv-qualifiers.
|
||||
/// Then, the result of applying <tt>as_expr\<T\>()(t)</tt> is
|
||||
/// <tt>Generator()(E\<tag::terminal, term\<A\> \>::make(t))</tt>.
|
||||
///
|
||||
/// If \c T is a Proto expression type and its generator type is different from
|
||||
/// \c Generator, the result is <tt>Generator()(t)</tt>.
|
||||
///
|
||||
/// Otherwise, the result is \c t converted to an (un-const) rvalue.
|
||||
///
|
||||
template<typename T, typename IsExpr = void, typename Callable = proto::callable>
|
||||
struct as_expr
|
||||
: detail::as_expr<
|
||||
T
|
||||
, typename detail::base_generator<Generator>::type
|
||||
, wants_basic_expr<Generator>::value
|
||||
>
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename T>
|
||||
struct as_expr<T, typename T::proto_is_expr_, proto::callable>
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
typedef typename remove_const<T>::type result_type;
|
||||
|
||||
result_type operator()(T &e) const
|
||||
{
|
||||
return e;
|
||||
}
|
||||
};
|
||||
|
||||
/// \brief A unary MonomorphicFunctionObject that turns objects into Proto
|
||||
/// expression objects in this domain.
|
||||
///
|
||||
/// The <tt>as_child\<\></tt> function object turns objects into Proto expressions, if
|
||||
/// they are not already, by making them Proto terminals held by reference.
|
||||
/// Objects that are already Proto expressions are simply returned by reference.
|
||||
///
|
||||
/// If <tt>wants_basic_expr\<Generator\>::value</tt> is true, then let \c E be \c basic_expr;
|
||||
/// otherwise, let \t E be \c expr. Given an lvalue \c t of type \c T:
|
||||
///
|
||||
/// If \c T is not a Proto expression type the resulting terminal is
|
||||
/// <tt>Generator()(E\<tag::terminal, term\<T &\> \>::make(t))</tt>.
|
||||
///
|
||||
/// If \c T is a Proto expression type and its generator type is different from
|
||||
/// \c Generator, the result is <tt>Generator()(t)</tt>.
|
||||
///
|
||||
/// Otherwise, the result is the lvalue \c t.
|
||||
///
|
||||
template<typename T, typename IsExpr = void, typename Callable = proto::callable>
|
||||
struct as_child
|
||||
: detail::as_child<
|
||||
T
|
||||
, typename detail::base_generator<Generator>::type
|
||||
, wants_basic_expr<Generator>::value
|
||||
>
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename T>
|
||||
struct as_child<T, typename T::proto_is_expr_, proto::callable>
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
typedef T &result_type;
|
||||
|
||||
result_type operator()(T &e) const
|
||||
{
|
||||
return e;
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
/// \brief The domain expressions have by default, if
|
||||
/// \c proto::extends\<\> has not been used to associate
|
||||
/// a domain with an expression.
|
||||
///
|
||||
struct default_domain
|
||||
: domain<>
|
||||
{};
|
||||
|
||||
/// \brief A domain to use when you prefer the use of
|
||||
/// \c proto::basic_expr\<\> over \c proto::expr\<\>.
|
||||
///
|
||||
struct basic_default_domain
|
||||
: domain<basic_default_generator>
|
||||
{};
|
||||
|
||||
/// \brief A pseudo-domain for use in functions and
|
||||
/// metafunctions that require a domain parameter. It
|
||||
/// indicates that the domain of the parent node should
|
||||
/// be inferred from the domains of the child nodes.
|
||||
///
|
||||
/// \attention \c deduce_domain is not itself a valid domain.
|
||||
///
|
||||
struct deduce_domain
|
||||
: domain<detail::not_a_generator, detail::not_a_grammar, detail::not_a_domain>
|
||||
{};
|
||||
|
||||
/// \brief Given a domain, a tag type and an argument list,
|
||||
/// compute the type of the expression to generate. This is
|
||||
/// either an instance of \c proto::expr\<\> or
|
||||
/// \c proto::basic_expr\<\>.
|
||||
///
|
||||
template<typename Domain, typename Tag, typename Args, bool WantsBasicExpr>
|
||||
struct base_expr
|
||||
{
|
||||
typedef proto::expr<Tag, Args, Args::arity> type;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename Domain, typename Tag, typename Args>
|
||||
struct base_expr<Domain, Tag, Args, true>
|
||||
{
|
||||
typedef proto::basic_expr<Tag, Args, Args::arity> type;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
/// A metafunction that returns \c mpl::true_
|
||||
/// if the type \c T is the type of a Proto domain;
|
||||
/// \c mpl::false_ otherwise. If \c T inherits from
|
||||
/// \c proto::domain\<\>, \c is_domain\<T\> is
|
||||
/// \c mpl::true_.
|
||||
template<typename T, typename Void /* = void*/>
|
||||
struct is_domain
|
||||
: mpl::false_
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename T>
|
||||
struct is_domain<T, typename T::proto_is_domain_>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
/// A metafunction that returns the domain of
|
||||
/// a given type. If \c T is a Proto expression
|
||||
/// type, it returns that expression's associated
|
||||
/// domain. If not, it returns
|
||||
/// \c proto::default_domain.
|
||||
template<typename T, typename Void /* = void*/>
|
||||
struct domain_of
|
||||
{
|
||||
typedef default_domain type;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename T>
|
||||
struct domain_of<T, typename T::proto_is_expr_>
|
||||
{
|
||||
typedef typename T::proto_domain type;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename T>
|
||||
struct domain_of<T &, void>
|
||||
{
|
||||
typedef typename domain_of<T>::type type;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename T>
|
||||
struct domain_of<boost::reference_wrapper<T>, void>
|
||||
{
|
||||
typedef typename domain_of<T>::type type;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename T>
|
||||
struct domain_of<boost::reference_wrapper<T> const, void>
|
||||
{
|
||||
typedef typename domain_of<T>::type type;
|
||||
};
|
||||
|
||||
/// A metafunction that returns \c mpl::true_
|
||||
/// if the type \c SubDomain is a sub-domain of
|
||||
/// \c SuperDomain; \c mpl::false_ otherwise.
|
||||
template<typename SubDomain, typename SuperDomain>
|
||||
struct is_sub_domain_of
|
||||
: is_sub_domain_of<typename SubDomain::proto_super_domain, SuperDomain>
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename SuperDomain>
|
||||
struct is_sub_domain_of<proto::no_super_domain, SuperDomain>
|
||||
: mpl::false_
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename SuperDomain>
|
||||
struct is_sub_domain_of<SuperDomain, SuperDomain>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
}}
|
||||
|
||||
#endif
|
||||
140
test/external/boost/proto/eval.hpp
vendored
Normal file
140
test/external/boost/proto/eval.hpp
vendored
Normal file
@@ -0,0 +1,140 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \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/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
|
||||
145
test/external/boost/proto/expr.hpp
vendored
Normal file
145
test/external/boost/proto/expr.hpp
vendored
Normal file
@@ -0,0 +1,145 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file expr.hpp
|
||||
/// Contains definition of expr\<\> class template.
|
||||
//
|
||||
// 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_EXPR_HPP_EAN_04_01_2005
|
||||
#define BOOST_PROTO_EXPR_HPP_EAN_04_01_2005
|
||||
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/arithmetic/dec.hpp>
|
||||
#include <boost/preprocessor/selection/max.hpp>
|
||||
#include <boost/preprocessor/iteration/iterate.hpp>
|
||||
#include <boost/preprocessor/facilities/intercept.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
|
||||
#include <boost/utility/addressof.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/args.hpp>
|
||||
#include <boost/proto/traits.hpp>
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4510) // default constructor could not be generated
|
||||
# pragma warning(disable : 4512) // assignment operator could not be generated
|
||||
# pragma warning(disable : 4610) // user defined constructor required
|
||||
#endif
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
|
||||
namespace detail
|
||||
{
|
||||
struct not_a_valid_type
|
||||
{
|
||||
private:
|
||||
not_a_valid_type()
|
||||
{}
|
||||
};
|
||||
|
||||
template<typename Tag, typename Arg>
|
||||
struct address_of_hack
|
||||
{
|
||||
typedef not_a_valid_type type;
|
||||
};
|
||||
|
||||
template<typename Expr>
|
||||
struct address_of_hack<proto::tag::address_of, Expr &>
|
||||
{
|
||||
typedef Expr *type;
|
||||
};
|
||||
|
||||
template<typename T, typename Expr, typename Arg0>
|
||||
Expr make_terminal(T &t, Expr *, proto::term<Arg0> *)
|
||||
{
|
||||
Expr that = {t};
|
||||
return that;
|
||||
}
|
||||
|
||||
template<typename T, typename Expr, typename Arg0, std::size_t N>
|
||||
Expr make_terminal(T (&t)[N], Expr *, proto::term<Arg0[N]> *)
|
||||
{
|
||||
Expr that;
|
||||
for(std::size_t i = 0; i < N; ++i)
|
||||
{
|
||||
that.child0[i] = t[i];
|
||||
}
|
||||
return that;
|
||||
}
|
||||
|
||||
template<typename T, typename Expr, typename Arg0, std::size_t N>
|
||||
Expr make_terminal(T const(&t)[N], Expr *, proto::term<Arg0[N]> *)
|
||||
{
|
||||
Expr that;
|
||||
for(std::size_t i = 0; i < N; ++i)
|
||||
{
|
||||
that.child0[i] = t[i];
|
||||
}
|
||||
return that;
|
||||
}
|
||||
|
||||
template<typename T, typename U>
|
||||
struct same_cv
|
||||
{
|
||||
typedef U type;
|
||||
};
|
||||
|
||||
template<typename T, typename U>
|
||||
struct same_cv<T const, U>
|
||||
{
|
||||
typedef U const type;
|
||||
};
|
||||
}
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
/// \brief A helper metafunction for computing the
|
||||
/// return type of \c proto::expr\<\>::operator().
|
||||
template<typename Sig, typename This, typename Domain>
|
||||
struct funop;
|
||||
|
||||
#include <boost/proto/detail/funop.hpp>
|
||||
}
|
||||
|
||||
namespace exprns_
|
||||
{
|
||||
// This is where the basic_expr specializations are
|
||||
// actually defined:
|
||||
#include <boost/proto/detail/basic_expr.hpp>
|
||||
|
||||
// This is where the expr specialization are
|
||||
// actually defined:
|
||||
#include <boost/proto/detail/expr.hpp>
|
||||
}
|
||||
|
||||
/// \brief Lets you inherit the interface of an expression
|
||||
/// while hiding from Proto the fact that the type is a Proto
|
||||
/// expression.
|
||||
template<typename Expr>
|
||||
struct unexpr
|
||||
: Expr
|
||||
{
|
||||
BOOST_PROTO_UNEXPR()
|
||||
|
||||
explicit unexpr(Expr const &e)
|
||||
: Expr(e)
|
||||
{}
|
||||
|
||||
using Expr::operator =;
|
||||
};
|
||||
|
||||
}}
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_PROTO_EXPR_HPP_EAN_04_01_2005
|
||||
626
test/external/boost/proto/extends.hpp
vendored
Normal file
626
test/external/boost/proto/extends.hpp
vendored
Normal file
@@ -0,0 +1,626 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file extends.hpp
|
||||
/// Macros and a base class for defining end-user expression types
|
||||
//
|
||||
// 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_EXTENDS_HPP_EAN_11_1_2006
|
||||
#define BOOST_PROTO_EXTENDS_HPP_EAN_11_1_2006
|
||||
|
||||
#include <cstddef> // for offsetof
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/preprocessor/facilities/empty.hpp>
|
||||
#include <boost/preprocessor/tuple/elem.hpp>
|
||||
#include <boost/preprocessor/control/if.hpp>
|
||||
#include <boost/preprocessor/arithmetic/inc.hpp>
|
||||
#include <boost/preprocessor/arithmetic/dec.hpp>
|
||||
#include <boost/preprocessor/iteration/local.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
|
||||
#include <boost/preprocessor/seq/for_each.hpp>
|
||||
#include <boost/utility/addressof.hpp>
|
||||
#include <boost/utility/result_of.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/traits.hpp>
|
||||
#include <boost/proto/expr.hpp>
|
||||
#include <boost/proto/args.hpp>
|
||||
#include <boost/proto/traits.hpp>
|
||||
#include <boost/proto/generate.hpp>
|
||||
#include <boost/proto/detail/remove_typename.hpp>
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#define BOOST_PROTO_DISABLE_MSVC_C4522 __pragma(warning(disable: 4522))
|
||||
#else
|
||||
#define BOOST_PROTO_DISABLE_MSVC_C4522
|
||||
#endif
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
#ifdef __GNUC__
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
# define BOOST_PROTO_ADDROF(x) ((char const volatile*)boost::addressof(x))
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
# define BOOST_PROTO_OFFSETOF(s,m) (BOOST_PROTO_ADDROF((((s *)this)->m)) - BOOST_PROTO_ADDROF(*((s *)this)))
|
||||
#else
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
# define BOOST_PROTO_OFFSETOF offsetof
|
||||
#endif
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_CONST() const
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_TYPENAME() typename
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_TEMPLATE_YES_(Z, N) template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)>
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_TEMPLATE_NO_(Z, N)
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, Const) \
|
||||
BOOST_PP_IF(N, BOOST_PROTO_TEMPLATE_YES_, BOOST_PROTO_TEMPLATE_NO_)(Z, N) \
|
||||
typename BOOST_PROTO_RESULT_OF< \
|
||||
proto_generator( \
|
||||
typename boost::proto::result_of::BOOST_PP_CAT(funop, N)< \
|
||||
proto_derived_expr Const() \
|
||||
, proto_domain \
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, const A) \
|
||||
>::type \
|
||||
) \
|
||||
>::type const \
|
||||
operator ()(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a)) Const() \
|
||||
{ \
|
||||
typedef boost::proto::result_of::BOOST_PP_CAT(funop, N)< \
|
||||
proto_derived_expr Const() \
|
||||
, proto_domain \
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, const A) \
|
||||
> funop; \
|
||||
return proto_generator()( \
|
||||
funop::call( \
|
||||
*static_cast<proto_derived_expr Const() *>(this) \
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, a) \
|
||||
) \
|
||||
); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(Const) \
|
||||
template<typename... A> \
|
||||
typename BOOST_PROTO_RESULT_OF< \
|
||||
proto_generator( \
|
||||
typename boost::proto::result_of::funop< \
|
||||
proto_derived_expr Const()(A const &...) \
|
||||
, proto_derived_expr \
|
||||
, proto_domain \
|
||||
>::type \
|
||||
) \
|
||||
>::type const \
|
||||
operator ()(A const &...a) Const() \
|
||||
{ \
|
||||
typedef boost::proto::result_of::funop< \
|
||||
proto_derived_expr Const()(A const &...) \
|
||||
, proto_derived_expr \
|
||||
, proto_domain \
|
||||
> funop; \
|
||||
return proto_generator()( \
|
||||
funop::call( \
|
||||
*static_cast<proto_derived_expr Const() *>(this) \
|
||||
, a... \
|
||||
) \
|
||||
); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_DEFINE_FUN_OP_CONST(Z, N, DATA) \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_DEFINE_FUN_OP_NON_CONST(Z, N, DATA) \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, BOOST_PP_EMPTY) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_DEFINE_FUN_OP(Z, N, DATA) \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_CONST(Z, N, DATA) \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_NON_CONST(Z, N, DATA) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_CHILD(Z, N, DATA) \
|
||||
typedef \
|
||||
typename proto_base_expr::BOOST_PP_CAT(proto_child, N) \
|
||||
BOOST_PP_CAT(proto_child, N); \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain) \
|
||||
Expr proto_expr_; \
|
||||
\
|
||||
typedef Expr proto_base_expr_; /**< INTERNAL ONLY */ \
|
||||
typedef typename proto_base_expr_::proto_base_expr proto_base_expr; \
|
||||
typedef BOOST_PROTO_REMOVE_TYPENAME(Domain) proto_domain; \
|
||||
typedef Derived proto_derived_expr; \
|
||||
typedef Domain::proto_generator proto_generator; \
|
||||
typedef typename proto_base_expr::proto_tag proto_tag; \
|
||||
typedef typename proto_base_expr::proto_args proto_args; \
|
||||
typedef typename proto_base_expr::proto_arity proto_arity; \
|
||||
typedef typename proto_base_expr::proto_grammar proto_grammar; \
|
||||
typedef typename proto_base_expr::address_of_hack_type_ proto_address_of_hack_type_; \
|
||||
typedef void proto_is_expr_; /**< INTERNAL ONLY */ \
|
||||
static const long proto_arity_c = proto_base_expr::proto_arity_c; \
|
||||
typedef boost::proto::tag::proto_expr fusion_tag; \
|
||||
BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_EXTENDS_CHILD, ~) \
|
||||
\
|
||||
static proto_derived_expr const make(Expr const &e) \
|
||||
{ \
|
||||
proto_derived_expr that = {e}; \
|
||||
return that; \
|
||||
} \
|
||||
\
|
||||
proto_base_expr &proto_base() \
|
||||
{ \
|
||||
return this->proto_expr_.proto_base(); \
|
||||
} \
|
||||
\
|
||||
proto_base_expr const &proto_base() const \
|
||||
{ \
|
||||
return this->proto_expr_.proto_base(); \
|
||||
} \
|
||||
\
|
||||
operator proto_address_of_hack_type_() const \
|
||||
{ \
|
||||
return boost::addressof(this->proto_base().child0); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain) \
|
||||
BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain) \
|
||||
typedef void proto_is_aggregate_; \
|
||||
/**< INTERNAL ONLY */
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, Const, Typename) \
|
||||
BOOST_PROTO_DISABLE_MSVC_C4522 \
|
||||
Typename() BOOST_PROTO_RESULT_OF< \
|
||||
Typename() This::proto_generator( \
|
||||
Typename() boost::proto::base_expr< \
|
||||
Typename() This::proto_domain \
|
||||
, boost::proto::tag::assign \
|
||||
, boost::proto::list2< \
|
||||
This & \
|
||||
, This Const() & \
|
||||
> \
|
||||
>::type \
|
||||
) \
|
||||
>::type const \
|
||||
operator =(This Const() &a) \
|
||||
{ \
|
||||
typedef \
|
||||
Typename() boost::proto::base_expr< \
|
||||
Typename() This::proto_domain \
|
||||
, boost::proto::tag::assign \
|
||||
, boost::proto::list2< \
|
||||
This & \
|
||||
, This Const() & \
|
||||
> \
|
||||
>::type \
|
||||
that_type; \
|
||||
that_type const that = { \
|
||||
*this \
|
||||
, a \
|
||||
}; \
|
||||
return Typename() This::proto_generator()(that); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
// MSVC 8.0 and higher seem to need copy-assignment operator to be overloaded on *both*
|
||||
// const and non-const rhs arguments.
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600)) && (BOOST_MSVC > 1310)
|
||||
#define BOOST_PROTO_EXTENDS_COPY_ASSIGN_(This, Typename) \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PP_EMPTY, Typename) \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PROTO_CONST, Typename) \
|
||||
/**/
|
||||
#else
|
||||
#define BOOST_PROTO_EXTENDS_COPY_ASSIGN_(This, Typename) \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PROTO_CONST, Typename) \
|
||||
/**/
|
||||
#endif
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(ThisConst, ThatConst) \
|
||||
template<typename A> \
|
||||
typename BOOST_PROTO_RESULT_OF< \
|
||||
proto_generator( \
|
||||
typename boost::proto::base_expr< \
|
||||
proto_domain \
|
||||
, boost::proto::tag::assign \
|
||||
, boost::proto::list2< \
|
||||
proto_derived_expr ThisConst() & \
|
||||
, typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
|
||||
> \
|
||||
>::type \
|
||||
) \
|
||||
>::type const \
|
||||
operator =(A ThatConst() &a) ThisConst() \
|
||||
{ \
|
||||
typedef \
|
||||
typename boost::proto::base_expr< \
|
||||
proto_domain \
|
||||
, boost::proto::tag::assign \
|
||||
, boost::proto::list2< \
|
||||
proto_derived_expr ThisConst() & \
|
||||
, typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
|
||||
> \
|
||||
>::type \
|
||||
that_type; \
|
||||
that_type const that = { \
|
||||
*static_cast<proto_derived_expr ThisConst() *>(this) \
|
||||
, boost::proto::as_child<proto_domain>(a) \
|
||||
}; \
|
||||
return proto_generator()(that); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN_CONST_() \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PROTO_CONST, BOOST_PP_EMPTY) \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PROTO_CONST, BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_() \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PP_EMPTY, BOOST_PP_EMPTY) \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PP_EMPTY, BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN_() \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_CONST_() \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_() \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN_CONST() \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME) \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_CONST_() \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST() \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME) \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_() \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN() \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME) \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_() \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(ThisConst, ThatConst) \
|
||||
template<typename A> \
|
||||
typename BOOST_PROTO_RESULT_OF< \
|
||||
proto_generator( \
|
||||
typename boost::proto::base_expr< \
|
||||
proto_domain \
|
||||
, boost::proto::tag::subscript \
|
||||
, boost::proto::list2< \
|
||||
proto_derived_expr ThisConst() & \
|
||||
, typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
|
||||
> \
|
||||
>::type \
|
||||
) \
|
||||
>::type const \
|
||||
operator [](A ThatConst() &a) ThisConst() \
|
||||
{ \
|
||||
typedef \
|
||||
typename boost::proto::base_expr< \
|
||||
proto_domain \
|
||||
, boost::proto::tag::subscript \
|
||||
, boost::proto::list2< \
|
||||
proto_derived_expr ThisConst() & \
|
||||
, typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
|
||||
> \
|
||||
>::type \
|
||||
that_type; \
|
||||
that_type const that = { \
|
||||
*static_cast<proto_derived_expr ThisConst() *>(this) \
|
||||
, boost::proto::as_child<proto_domain>(a) \
|
||||
}; \
|
||||
return proto_generator()(that); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST() \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST, BOOST_PP_EMPTY) \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST, BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST() \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY, BOOST_PP_EMPTY) \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY, BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_SUBSCRIPT() \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST() \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST() \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
template<typename Sig> \
|
||||
struct result \
|
||||
{ \
|
||||
typedef \
|
||||
typename BOOST_PROTO_RESULT_OF< \
|
||||
proto_generator( \
|
||||
typename boost::proto::result_of::funop< \
|
||||
Sig \
|
||||
, proto_derived_expr \
|
||||
, proto_domain \
|
||||
>::type \
|
||||
) \
|
||||
>::type const \
|
||||
type; \
|
||||
}; \
|
||||
/**/
|
||||
|
||||
#ifndef BOOST_NO_VARIADIC_TEMPLATES
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION_CONST() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY) \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
#else
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION_CONST() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
BOOST_PP_REPEAT_FROM_TO( \
|
||||
0 \
|
||||
, BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \
|
||||
, BOOST_PROTO_DEFINE_FUN_OP_CONST \
|
||||
, ~ \
|
||||
) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
BOOST_PP_REPEAT_FROM_TO( \
|
||||
0 \
|
||||
, BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \
|
||||
, BOOST_PROTO_DEFINE_FUN_OP_NON_CONST \
|
||||
, ~ \
|
||||
) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
BOOST_PP_REPEAT_FROM_TO( \
|
||||
0 \
|
||||
, BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \
|
||||
, BOOST_PROTO_DEFINE_FUN_OP \
|
||||
, ~ \
|
||||
) \
|
||||
/**/
|
||||
#endif
|
||||
|
||||
#define BOOST_PROTO_EXTENDS(Expr, Derived, Domain) \
|
||||
BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain) \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN() \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION() \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_USING_ASSIGN(Derived) \
|
||||
typedef typename Derived::proto_extends proto_extends; \
|
||||
using proto_extends::operator =; \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_(Derived, BOOST_PROTO_TYPENAME) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_USING_ASSIGN_NON_DEPENDENT(Derived) \
|
||||
typedef Derived::proto_extends proto_extends; \
|
||||
using proto_extends::operator =; \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_(Derived, BOOST_PP_EMPTY) \
|
||||
/**/
|
||||
|
||||
namespace exprns_
|
||||
{
|
||||
/// \brief Empty type to be used as a dummy template parameter of
|
||||
/// POD expression wrappers. It allows argument-dependent lookup
|
||||
/// to find Proto's operator overloads.
|
||||
///
|
||||
/// \c proto::is_proto_expr allows argument-dependent lookup
|
||||
/// to find Proto's operator overloads. For example:
|
||||
///
|
||||
/// \code
|
||||
/// template<typename T, typename Dummy = proto::is_proto_expr>
|
||||
/// struct my_terminal
|
||||
/// {
|
||||
/// BOOST_PROTO_BASIC_EXTENDS(
|
||||
/// typename proto::terminal<T>::type
|
||||
/// , my_terminal<T>
|
||||
/// , default_domain
|
||||
/// )
|
||||
/// };
|
||||
///
|
||||
/// // ...
|
||||
/// my_terminal<int> _1, _2;
|
||||
/// _1 + _2; // OK, uses proto::operator+
|
||||
/// \endcode
|
||||
///
|
||||
/// Without the second \c Dummy template parameter, Proto's operator
|
||||
/// overloads would not be considered by name lookup.
|
||||
struct is_proto_expr
|
||||
{};
|
||||
|
||||
/// \brief extends\<\> class template for adding behaviors to a Proto expression template
|
||||
///
|
||||
template<
|
||||
typename Expr
|
||||
, typename Derived
|
||||
, typename Domain // = proto::default_domain
|
||||
, long Arity // = Expr::proto_arity_c
|
||||
>
|
||||
struct extends
|
||||
{
|
||||
extends()
|
||||
: proto_expr_()
|
||||
{}
|
||||
|
||||
extends(extends const &that)
|
||||
: proto_expr_(that.proto_expr_)
|
||||
{}
|
||||
|
||||
extends(Expr const &expr_)
|
||||
: proto_expr_(expr_)
|
||||
{}
|
||||
|
||||
typedef extends proto_extends;
|
||||
BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, typename Domain)
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_CONST_()
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST()
|
||||
|
||||
// Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
|
||||
// nested preprocessor loops, use file iteration here to generate
|
||||
// the operator() overloads, which is more efficient.
|
||||
#include <boost/proto/detail/extends_funop_const.hpp>
|
||||
};
|
||||
|
||||
/// \brief extends\<\> class template for adding behaviors to a Proto expression template
|
||||
///
|
||||
template<typename Expr, typename Derived, typename Domain>
|
||||
struct extends<Expr, Derived, Domain, 0>
|
||||
{
|
||||
extends()
|
||||
: proto_expr_()
|
||||
{}
|
||||
|
||||
extends(extends const &that)
|
||||
: proto_expr_(that.proto_expr_)
|
||||
{}
|
||||
|
||||
extends(Expr const &expr_)
|
||||
: proto_expr_(expr_)
|
||||
{}
|
||||
|
||||
typedef extends proto_extends;
|
||||
BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, typename Domain)
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_()
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT()
|
||||
|
||||
// Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
|
||||
// nested preprocessor loops, use file iteration here to generate
|
||||
// the operator() overloads, which is more efficient.
|
||||
#include <boost/proto/detail/extends_funop.hpp>
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename This, typename Fun, typename Domain>
|
||||
struct virtual_member
|
||||
{
|
||||
typedef Domain proto_domain;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef virtual_member<This, Fun, Domain> proto_derived_expr;
|
||||
typedef tag::member proto_tag;
|
||||
typedef list2<This &, expr<tag::terminal, term<Fun> > const &> proto_args;
|
||||
typedef mpl::long_<2> proto_arity;
|
||||
typedef detail::not_a_valid_type proto_address_of_hack_type_;
|
||||
typedef void proto_is_expr_; /**< INTERNAL ONLY */
|
||||
static const long proto_arity_c = 2;
|
||||
typedef boost::proto::tag::proto_expr fusion_tag;
|
||||
typedef This &proto_child0;
|
||||
typedef expr<tag::terminal, term<Fun> > const &proto_child1;
|
||||
typedef expr<proto_tag, proto_args, proto_arity_c> proto_base_expr;
|
||||
typedef basic_expr<proto_tag, proto_args, proto_arity_c> proto_grammar;
|
||||
typedef void proto_is_aggregate_; /**< INTERNAL ONLY */
|
||||
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_()
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT()
|
||||
|
||||
// Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
|
||||
// nested preprocessor loops, use file iteration here to generate
|
||||
// the operator() overloads, which is more efficient.
|
||||
#define BOOST_PROTO_NO_WAVE_OUTPUT
|
||||
#include <boost/proto/detail/extends_funop.hpp>
|
||||
#undef BOOST_PROTO_NO_WAVE_OUTPUT
|
||||
|
||||
proto_base_expr const proto_base() const
|
||||
{
|
||||
proto_base_expr that = {this->child0(), this->child1()};
|
||||
return that;
|
||||
}
|
||||
|
||||
proto_child0 child0() const
|
||||
{
|
||||
using std::size_t;
|
||||
return *(This *)((char *)this - BOOST_PROTO_OFFSETOF(This, proto_member_union_start_));
|
||||
}
|
||||
|
||||
proto_child1 child1() const
|
||||
{
|
||||
static expr<tag::terminal, term<Fun>, 0> const that = {Fun()};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_MEMBER_(R, DOMAIN, ELEM) \
|
||||
boost::proto::exprns_::virtual_member< \
|
||||
proto_derived_expr \
|
||||
, BOOST_PP_TUPLE_ELEM(2, 0, ELEM) \
|
||||
, DOMAIN \
|
||||
> BOOST_PP_TUPLE_ELEM(2, 1, ELEM); \
|
||||
/**/
|
||||
|
||||
/// \brief For declaring virtual data members in an extension class.
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_MEMBERS_WITH_DOMAIN(SEQ, DOMAIN) \
|
||||
union \
|
||||
{ \
|
||||
char proto_member_union_start_; \
|
||||
BOOST_PP_SEQ_FOR_EACH(BOOST_PROTO_EXTENDS_MEMBER_, DOMAIN, SEQ) \
|
||||
}; \
|
||||
/**/
|
||||
|
||||
/// \brief For declaring virtual data members in an extension class.
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_MEMBERS(SEQ) \
|
||||
BOOST_PROTO_EXTENDS_MEMBERS_WITH_DOMAIN(SEQ, proto_domain) \
|
||||
/**/
|
||||
|
||||
}
|
||||
|
||||
}}
|
||||
|
||||
#endif
|
||||
15
test/external/boost/proto/functional.hpp
vendored
Normal file
15
test/external/boost/proto/functional.hpp
vendored
Normal file
@@ -0,0 +1,15 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file functional.hpp
|
||||
/// Proto callables for various things
|
||||
//
|
||||
// Copyright 2010 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_FUNCTIONAL_HPP_EAN_11_27_2010
|
||||
#define BOOST_PROTO_FUNCTIONAL_HPP_EAN_11_27_2010
|
||||
|
||||
#include <boost/proto/functional/std.hpp>
|
||||
#include <boost/proto/functional/fusion.hpp>
|
||||
|
||||
#endif
|
||||
19
test/external/boost/proto/functional/fusion.hpp
vendored
Normal file
19
test/external/boost/proto/functional/fusion.hpp
vendored
Normal file
@@ -0,0 +1,19 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file fusion.hpp
|
||||
/// Proto callables for things found in the Fusion library
|
||||
//
|
||||
// Copyright 2010 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_FUNCTIONAL_FUSION_HPP_EAN_11_27_2010
|
||||
#define BOOST_PROTO_FUNCTIONAL_FUSION_HPP_EAN_11_27_2010
|
||||
|
||||
#include <boost/proto/functional/fusion/at.hpp>
|
||||
#include <boost/proto/functional/fusion/pop_back.hpp>
|
||||
#include <boost/proto/functional/fusion/pop_front.hpp>
|
||||
#include <boost/proto/functional/fusion/push_back.hpp>
|
||||
#include <boost/proto/functional/fusion/push_front.hpp>
|
||||
#include <boost/proto/functional/fusion/reverse.hpp>
|
||||
|
||||
#endif
|
||||
56
test/external/boost/proto/functional/fusion/at.hpp
vendored
Normal file
56
test/external/boost/proto/functional/fusion/at.hpp
vendored
Normal file
@@ -0,0 +1,56 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file at.hpp
|
||||
/// Proto callables Fusion at
|
||||
//
|
||||
// Copyright 2010 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_FUNCTIONAL_FUSION_AT_HPP_EAN_11_27_2010
|
||||
#define BOOST_PROTO_FUNCTIONAL_FUSION_AT_HPP_EAN_11_27_2010
|
||||
|
||||
#include <boost/type_traits/add_const.hpp>
|
||||
#include <boost/type_traits/remove_const.hpp>
|
||||
#include <boost/type_traits/remove_reference.hpp>
|
||||
#include <boost/fusion/include/at.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
|
||||
namespace boost { namespace proto { namespace functional
|
||||
{
|
||||
/// \brief A PolymorphicFunctionObject type that invokes the
|
||||
/// \c fusion::at() accessor on its argument.
|
||||
///
|
||||
/// A PolymorphicFunctionObject type that invokes the
|
||||
/// \c fusion::at() accessor on its argument.
|
||||
struct at
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename Seq, typename N>
|
||||
struct result<This(Seq, N)>
|
||||
: fusion::result_of::at<
|
||||
typename boost::remove_reference<Seq>::type
|
||||
, typename boost::remove_const<typename boost::remove_reference<N>::type>::type
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Seq, typename N>
|
||||
typename fusion::result_of::at<Seq, N>::type
|
||||
operator ()(Seq &seq, N const & BOOST_PROTO_DISABLE_IF_IS_CONST(Seq)) const
|
||||
{
|
||||
return fusion::at<N>(seq);
|
||||
}
|
||||
|
||||
template<typename Seq, typename N>
|
||||
typename fusion::result_of::at<Seq const, N>::type
|
||||
operator ()(Seq const &seq, N const &) const
|
||||
{
|
||||
return fusion::at<N>(seq);
|
||||
}
|
||||
};
|
||||
}}}
|
||||
|
||||
#endif
|
||||
60
test/external/boost/proto/functional/fusion/pop_back.hpp
vendored
Normal file
60
test/external/boost/proto/functional/fusion/pop_back.hpp
vendored
Normal file
@@ -0,0 +1,60 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file pop_back.hpp
|
||||
/// Proto callables Fusion pop_back
|
||||
//
|
||||
// Copyright 2010 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_FUNCTIONAL_FUSION_POP_BACK_HPP_EAN_11_27_2010
|
||||
#define BOOST_PROTO_FUNCTIONAL_FUSION_POP_BACK_HPP_EAN_11_27_2010
|
||||
|
||||
#include <boost/fusion/include/begin.hpp>
|
||||
#include <boost/fusion/include/end.hpp>
|
||||
#include <boost/fusion/include/prior.hpp>
|
||||
#include <boost/fusion/include/pop_back.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
|
||||
namespace boost { namespace proto { namespace functional
|
||||
{
|
||||
/// \brief A PolymorphicFunctionObject type that invokes the
|
||||
/// \c fusion::pop_back() algorithm on its argument.
|
||||
///
|
||||
/// A PolymorphicFunctionObject type that invokes the
|
||||
/// \c fusion::pop_back() algorithm on its argument.
|
||||
struct pop_back
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename Seq>
|
||||
struct result<This(Seq)>
|
||||
: result<This(Seq const &)>
|
||||
{};
|
||||
|
||||
template<typename This, typename Seq>
|
||||
struct result<This(Seq &)>
|
||||
: fusion::result_of::pop_back<Seq>
|
||||
{};
|
||||
|
||||
template<typename Seq>
|
||||
typename fusion::result_of::pop_back<Seq>::type
|
||||
operator ()(Seq &seq) const
|
||||
{
|
||||
// Work around a const-correctness issue in Fusion
|
||||
typedef typename fusion::result_of::pop_back<Seq>::type result_type;
|
||||
return result_type(fusion::begin(seq), fusion::prior(fusion::end(seq)));
|
||||
}
|
||||
|
||||
template<typename Seq>
|
||||
typename fusion::result_of::pop_back<Seq const>::type
|
||||
operator ()(Seq const &seq) const
|
||||
{
|
||||
return fusion::pop_back(seq);
|
||||
}
|
||||
};
|
||||
}}}
|
||||
|
||||
#endif
|
||||
65
test/external/boost/proto/functional/fusion/pop_front.hpp
vendored
Normal file
65
test/external/boost/proto/functional/fusion/pop_front.hpp
vendored
Normal file
@@ -0,0 +1,65 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file pop_front.hpp
|
||||
/// Proto callables Fusion pop_front
|
||||
//
|
||||
// Copyright 2010 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_FUNCTIONAL_FUSION_POP_FRONT_HPP_EAN_11_27_2010
|
||||
#define BOOST_PROTO_FUNCTIONAL_FUSION_POP_FRONT_HPP_EAN_11_27_2010
|
||||
|
||||
#include <boost/fusion/include/begin.hpp>
|
||||
#include <boost/fusion/include/end.hpp>
|
||||
#include <boost/fusion/include/next.hpp>
|
||||
#include <boost/fusion/include/pop_front.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
|
||||
namespace boost { namespace proto { namespace functional
|
||||
{
|
||||
/// \brief A PolymorphicFunctionObject type that invokes the
|
||||
/// \c fusion::pop_front() algorithm on its argument.
|
||||
///
|
||||
/// A PolymorphicFunctionObject type that invokes the
|
||||
/// \c fusion::pop_front() algorithm on its argument. This is
|
||||
/// useful for defining a CallableTransform like \c pop_front(_)
|
||||
/// which removes the first child from a Proto expression node.
|
||||
/// Such a transform might be used as the first argument to the
|
||||
/// \c proto::fold\<\> transform; that is, fold all but
|
||||
/// the first child.
|
||||
struct pop_front
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename Seq>
|
||||
struct result<This(Seq)>
|
||||
: result<This(Seq const &)>
|
||||
{};
|
||||
|
||||
template<typename This, typename Seq>
|
||||
struct result<This(Seq &)>
|
||||
: fusion::result_of::pop_front<Seq>
|
||||
{};
|
||||
|
||||
template<typename Seq>
|
||||
typename fusion::result_of::pop_front<Seq>::type
|
||||
operator ()(Seq &seq) const
|
||||
{
|
||||
// Work around a const-correctness issue in Fusion
|
||||
typedef typename fusion::result_of::pop_front<Seq>::type result_type;
|
||||
return result_type(fusion::next(fusion::begin(seq)), fusion::end(seq));
|
||||
}
|
||||
|
||||
template<typename Seq>
|
||||
typename fusion::result_of::pop_front<Seq const>::type
|
||||
operator ()(Seq const &seq) const
|
||||
{
|
||||
return fusion::pop_front(seq);
|
||||
}
|
||||
};
|
||||
}}}
|
||||
|
||||
#endif
|
||||
49
test/external/boost/proto/functional/fusion/push_back.hpp
vendored
Normal file
49
test/external/boost/proto/functional/fusion/push_back.hpp
vendored
Normal file
@@ -0,0 +1,49 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file push_back.hpp
|
||||
/// Proto callables Fusion push_back
|
||||
//
|
||||
// Copyright 2010 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_FUNCTIONAL_FUSION_PUSH_BACK_HPP_EAN_11_27_2010
|
||||
#define BOOST_PROTO_FUNCTIONAL_FUSION_PUSH_BACK_HPP_EAN_11_27_2010
|
||||
|
||||
#include <boost/type_traits/add_const.hpp>
|
||||
#include <boost/type_traits/remove_const.hpp>
|
||||
#include <boost/type_traits/remove_reference.hpp>
|
||||
#include <boost/fusion/include/push_back.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
|
||||
namespace boost { namespace proto { namespace functional
|
||||
{
|
||||
/// \brief A PolymorphicFunctionObject type that invokes the
|
||||
/// \c fusion::push_back() algorithm on its argument.
|
||||
///
|
||||
/// A PolymorphicFunctionObject type that invokes the
|
||||
/// \c fusion::push_back() algorithm on its argument.
|
||||
struct push_back
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename Seq, typename T>
|
||||
struct result<This(Seq, T)>
|
||||
: fusion::result_of::push_back<
|
||||
typename boost::add_const<typename boost::remove_reference<Seq>::type>::type
|
||||
, typename boost::remove_const<typename boost::remove_reference<T>::type>::type
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Seq, typename T>
|
||||
typename fusion::result_of::push_back<Seq const, T>::type
|
||||
operator ()(Seq const &seq, T const &t) const
|
||||
{
|
||||
return fusion::push_back(seq, t);
|
||||
}
|
||||
};
|
||||
}}}
|
||||
|
||||
#endif
|
||||
49
test/external/boost/proto/functional/fusion/push_front.hpp
vendored
Normal file
49
test/external/boost/proto/functional/fusion/push_front.hpp
vendored
Normal file
@@ -0,0 +1,49 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file push_front.hpp
|
||||
/// Proto callables Fusion push_front
|
||||
//
|
||||
// Copyright 2010 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_FUNCTIONAL_FUSION_PUSH_FRONT_HPP_EAN_11_27_2010
|
||||
#define BOOST_PROTO_FUNCTIONAL_FUSION_PUSH_FRONT_HPP_EAN_11_27_2010
|
||||
|
||||
#include <boost/type_traits/add_const.hpp>
|
||||
#include <boost/type_traits/remove_const.hpp>
|
||||
#include <boost/type_traits/remove_reference.hpp>
|
||||
#include <boost/fusion/include/push_front.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
|
||||
namespace boost { namespace proto { namespace functional
|
||||
{
|
||||
/// \brief A PolymorphicFunctionObject type that invokes the
|
||||
/// \c fusion::push_front() algorithm on its argument.
|
||||
///
|
||||
/// A PolymorphicFunctionObject type that invokes the
|
||||
/// \c fusion::push_front() algorithm on its argument.
|
||||
struct push_front
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename Seq, typename T>
|
||||
struct result<This(Seq, T)>
|
||||
: fusion::result_of::push_front<
|
||||
typename boost::add_const<typename boost::remove_reference<Seq>::type>::type
|
||||
, typename boost::remove_const<typename boost::remove_reference<T>::type>::type
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Seq, typename T>
|
||||
typename fusion::result_of::push_front<Seq const, T>::type
|
||||
operator ()(Seq const &seq, T const &t) const
|
||||
{
|
||||
return fusion::push_front(seq, t);
|
||||
}
|
||||
};
|
||||
}}}
|
||||
|
||||
#endif
|
||||
60
test/external/boost/proto/functional/fusion/reverse.hpp
vendored
Normal file
60
test/external/boost/proto/functional/fusion/reverse.hpp
vendored
Normal file
@@ -0,0 +1,60 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file reverse.hpp
|
||||
/// Proto callables Fusion reverse
|
||||
//
|
||||
// Copyright 2010 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_FUNCTIONAL_FUSION_REVERSE_HPP_EAN_11_27_2010
|
||||
#define BOOST_PROTO_FUNCTIONAL_FUSION_REVERSE_HPP_EAN_11_27_2010
|
||||
|
||||
#include <boost/fusion/include/reverse.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
|
||||
namespace boost { namespace proto { namespace functional
|
||||
{
|
||||
/// \brief A PolymorphicFunctionObject type that invokes the
|
||||
/// \c fusion::reverse() algorithm on its argument.
|
||||
///
|
||||
/// A PolymorphicFunctionObject type that invokes the
|
||||
/// \c fusion::reverse() algorithm on its argument. This is
|
||||
/// useful for defining a CallableTransform like \c reverse(_)
|
||||
/// which reverses the order of the children of a Proto
|
||||
/// expression node.
|
||||
struct reverse
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename Seq>
|
||||
struct result<This(Seq)>
|
||||
: result<This(Seq const &)>
|
||||
{};
|
||||
|
||||
template<typename This, typename Seq>
|
||||
struct result<This(Seq &)>
|
||||
: fusion::result_of::reverse<Seq>
|
||||
{};
|
||||
|
||||
template<typename Seq>
|
||||
typename fusion::result_of::reverse<Seq>::type
|
||||
operator ()(Seq &seq) const
|
||||
{
|
||||
// Work around a const-correctness issue in Fusion
|
||||
typedef typename fusion::result_of::reverse<Seq>::type result_type;
|
||||
return result_type(seq);
|
||||
}
|
||||
|
||||
template<typename Seq>
|
||||
typename fusion::result_of::reverse<Seq const>::type
|
||||
operator ()(Seq const &seq) const
|
||||
{
|
||||
return fusion::reverse(seq);
|
||||
}
|
||||
};
|
||||
}}}
|
||||
|
||||
#endif
|
||||
14
test/external/boost/proto/functional/std.hpp
vendored
Normal file
14
test/external/boost/proto/functional/std.hpp
vendored
Normal file
@@ -0,0 +1,14 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file std.hpp
|
||||
/// Proto callables for things found in the std library
|
||||
//
|
||||
// Copyright 2010 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_FUNCTIONAL_STD_HPP_EAN_11_27_2010
|
||||
#define BOOST_PROTO_FUNCTIONAL_STD_HPP_EAN_11_27_2010
|
||||
|
||||
#include <boost/proto/functional/std/utility.hpp>
|
||||
|
||||
#endif
|
||||
137
test/external/boost/proto/functional/std/utility.hpp
vendored
Normal file
137
test/external/boost/proto/functional/std/utility.hpp
vendored
Normal file
@@ -0,0 +1,137 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file utility.hpp
|
||||
/// Proto callables for things found in the std \<utility\> header
|
||||
//
|
||||
// Copyright 2010 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_FUNCTIONAL_STD_UTILITY_HPP_EAN_11_27_2010
|
||||
#define BOOST_PROTO_FUNCTIONAL_STD_UTILITY_HPP_EAN_11_27_2010
|
||||
|
||||
#include <utility>
|
||||
#include <boost/type_traits/remove_const.hpp>
|
||||
#include <boost/type_traits/remove_reference.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
|
||||
namespace boost { namespace proto { namespace functional
|
||||
{
|
||||
/// \brief A PolymorphicFunctionObject type that invokes the
|
||||
/// \c std::make_pair() algorithm on its arguments.
|
||||
///
|
||||
/// A PolymorphicFunctionObject type that invokes the
|
||||
/// \c std::make_pair() algorithm on its arguments.
|
||||
struct make_pair
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename First, typename Second>
|
||||
struct result<This(First, Second)>
|
||||
{
|
||||
typedef
|
||||
std::pair<
|
||||
typename remove_const<typename remove_reference<First>::type>::type
|
||||
, typename remove_const<typename remove_reference<Second>::type>::type
|
||||
>
|
||||
type;
|
||||
};
|
||||
|
||||
template<typename First, typename Second>
|
||||
std::pair<First, Second> operator()(First const &first, Second const &second) const
|
||||
{
|
||||
return std::make_pair(first, second);
|
||||
}
|
||||
};
|
||||
|
||||
/// \brief A PolymorphicFunctionObject type that returns
|
||||
/// the first element of a std::pair.
|
||||
///
|
||||
/// A PolymorphicFunctionObject type that returns
|
||||
/// the first element of a std::pair..
|
||||
struct first
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename Pair>
|
||||
struct result<This(Pair)>
|
||||
{
|
||||
typedef typename Pair::first_type type;
|
||||
};
|
||||
|
||||
template<typename This, typename Pair>
|
||||
struct result<This(Pair &)>
|
||||
{
|
||||
typedef typename Pair::first_type &type;
|
||||
};
|
||||
|
||||
template<typename This, typename Pair>
|
||||
struct result<This(Pair const &)>
|
||||
{
|
||||
typedef typename Pair::first_type const &type;
|
||||
};
|
||||
|
||||
template<typename Pair>
|
||||
typename Pair::first_type &operator()(Pair &pair) const
|
||||
{
|
||||
return pair.first;
|
||||
}
|
||||
|
||||
template<typename Pair>
|
||||
typename Pair::first_type const &operator()(Pair const &pair) const
|
||||
{
|
||||
return pair.first;
|
||||
}
|
||||
};
|
||||
|
||||
/// \brief A PolymorphicFunctionObject type that returns
|
||||
/// the second element of a std::pair.
|
||||
///
|
||||
/// A PolymorphicFunctionObject type that returns
|
||||
/// the second element of a std::pair..
|
||||
struct second
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename Pair>
|
||||
struct result<This(Pair)>
|
||||
{
|
||||
typedef typename Pair::second_type type;
|
||||
};
|
||||
|
||||
template<typename This, typename Pair>
|
||||
struct result<This(Pair &)>
|
||||
{
|
||||
typedef typename Pair::second_type &type;
|
||||
};
|
||||
|
||||
template<typename This, typename Pair>
|
||||
struct result<This(Pair const &)>
|
||||
{
|
||||
typedef typename Pair::second_type const &type;
|
||||
};
|
||||
|
||||
template<typename Pair>
|
||||
typename Pair::second_type &operator()(Pair &pair) const
|
||||
{
|
||||
return pair.second;
|
||||
}
|
||||
|
||||
template<typename Pair>
|
||||
typename Pair::second_type const &operator()(Pair const &pair) const
|
||||
{
|
||||
return pair.second;
|
||||
}
|
||||
};
|
||||
|
||||
}}}
|
||||
|
||||
#endif
|
||||
664
test/external/boost/proto/fusion.hpp
vendored
Normal file
664
test/external/boost/proto/fusion.hpp
vendored
Normal file
@@ -0,0 +1,664 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file fusion.hpp
|
||||
/// Make any Proto expression a valid Fusion sequence
|
||||
//
|
||||
// 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_FUSION_HPP_EAN_11_04_2006
|
||||
#define BOOST_PROTO_FUSION_HPP_EAN_11_04_2006
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/mpl/long.hpp>
|
||||
#include <boost/mpl/sequence_tag_fwd.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/fusion/include/is_view.hpp>
|
||||
#include <boost/fusion/include/tag_of_fwd.hpp>
|
||||
#include <boost/fusion/include/category_of.hpp>
|
||||
#include <boost/fusion/include/iterator_base.hpp>
|
||||
#include <boost/fusion/include/intrinsic.hpp>
|
||||
#include <boost/fusion/include/single_view.hpp>
|
||||
#include <boost/fusion/include/transform_view.hpp>
|
||||
#include <boost/fusion/include/is_segmented.hpp>
|
||||
#include <boost/fusion/sequence/comparison/enable_comparison.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/traits.hpp>
|
||||
#include <boost/proto/eval.hpp>
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable : 4510) // default constructor could not be generated
|
||||
#pragma warning(disable : 4512) // assignment operator could not be generated
|
||||
#pragma warning(disable : 4610) // can never be instantiated - user defined constructor required
|
||||
#endif
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
template<typename Expr, long Pos>
|
||||
struct expr_iterator
|
||||
: fusion::iterator_base<expr_iterator<Expr, Pos> >
|
||||
{
|
||||
typedef Expr expr_type;
|
||||
typedef typename Expr::proto_tag proto_tag;
|
||||
static const long index = Pos;
|
||||
typedef fusion::random_access_traversal_tag category;
|
||||
typedef tag::proto_expr_iterator fusion_tag;
|
||||
|
||||
expr_iterator(Expr &e)
|
||||
: expr(e)
|
||||
{}
|
||||
|
||||
Expr &expr;
|
||||
};
|
||||
|
||||
template<typename Expr>
|
||||
struct flat_view
|
||||
{
|
||||
typedef Expr expr_type;
|
||||
typedef typename Expr::proto_tag proto_tag;
|
||||
typedef fusion::forward_traversal_tag category;
|
||||
typedef tag::proto_flat_view fusion_tag;
|
||||
|
||||
explicit flat_view(Expr &e)
|
||||
: expr_(e)
|
||||
{}
|
||||
|
||||
Expr &expr_;
|
||||
};
|
||||
|
||||
template<typename Tag>
|
||||
struct as_element
|
||||
{
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr)>
|
||||
: result<This(Expr const &)>
|
||||
{};
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr &)>
|
||||
: mpl::if_c<
|
||||
is_same<Tag, typename Expr::proto_tag>::value
|
||||
, flat_view<Expr>
|
||||
, fusion::single_view<Expr &>
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr>
|
||||
typename result<as_element(Expr &)>::type const
|
||||
operator ()(Expr &e) const
|
||||
{
|
||||
return typename result<as_element(Expr &)>::type(e);
|
||||
}
|
||||
|
||||
template<typename Expr>
|
||||
typename result<as_element(Expr const &)>::type const
|
||||
operator ()(Expr const &e) const
|
||||
{
|
||||
return typename result<as_element(Expr const &)>::type(e);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template<typename Expr>
|
||||
struct flatten
|
||||
: flatten<Expr const &>
|
||||
{};
|
||||
|
||||
template<typename Expr>
|
||||
struct flatten<Expr &>
|
||||
{
|
||||
typedef detail::flat_view<Expr> type;
|
||||
};
|
||||
}
|
||||
|
||||
namespace functional
|
||||
{
|
||||
/// \brief A PolymorphicFunctionObject type that returns a "flattened"
|
||||
/// view of a Proto expression tree.
|
||||
///
|
||||
/// A PolymorphicFunctionObject type that returns a "flattened"
|
||||
/// view of a Proto expression tree. For a tree with a top-most node
|
||||
/// tag of type \c T, the elements of the flattened sequence are
|
||||
/// determined by recursing into each child node with the same
|
||||
/// tag type and returning those nodes of different type. So for
|
||||
/// instance, the Proto expression tree corresponding to the
|
||||
/// expression <tt>a | b | c</tt> has a flattened view with elements
|
||||
/// [a, b, c], even though the tree is grouped as
|
||||
/// <tt>((a | b) | c)</tt>.
|
||||
struct flatten
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr)>
|
||||
: result<This(Expr const &)>
|
||||
{};
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr &)>
|
||||
{
|
||||
typedef proto::detail::flat_view<Expr> type;
|
||||
};
|
||||
|
||||
template<typename Expr>
|
||||
proto::detail::flat_view<Expr> const
|
||||
operator ()(Expr &e) const
|
||||
{
|
||||
return proto::detail::flat_view<Expr>(e);
|
||||
}
|
||||
|
||||
template<typename Expr>
|
||||
proto::detail::flat_view<Expr const> const
|
||||
operator ()(Expr const &e) const
|
||||
{
|
||||
return proto::detail::flat_view<Expr const>(e);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/// \brief A function that returns a "flattened"
|
||||
/// view of a Proto expression tree.
|
||||
///
|
||||
/// For a tree with a top-most node
|
||||
/// tag of type \c T, the elements of the flattened sequence are
|
||||
/// determined by recursing into each child node with the same
|
||||
/// tag type and returning those nodes of different type. So for
|
||||
/// instance, the Proto expression tree corresponding to the
|
||||
/// expression <tt>a | b | c</tt> has a flattened view with elements
|
||||
/// [a, b, c], even though the tree is grouped as
|
||||
/// <tt>((a | b) | c)</tt>.
|
||||
template<typename Expr>
|
||||
proto::detail::flat_view<Expr> const
|
||||
flatten(Expr &e)
|
||||
{
|
||||
return proto::detail::flat_view<Expr>(e);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
///
|
||||
template<typename Expr>
|
||||
proto::detail::flat_view<Expr const> const
|
||||
flatten(Expr const &e)
|
||||
{
|
||||
return proto::detail::flat_view<Expr const>(e);
|
||||
}
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename Context>
|
||||
struct eval_fun
|
||||
: proto::callable
|
||||
{
|
||||
explicit eval_fun(Context &ctx)
|
||||
: ctx_(ctx)
|
||||
{}
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr)>
|
||||
: result<This(Expr const &)>
|
||||
{};
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr &)>
|
||||
: proto::result_of::eval<Expr, Context>
|
||||
{};
|
||||
|
||||
template<typename Expr>
|
||||
typename proto::result_of::eval<Expr, Context>::type
|
||||
operator ()(Expr &e) const
|
||||
{
|
||||
return proto::eval(e, this->ctx_);
|
||||
}
|
||||
|
||||
template<typename Expr>
|
||||
typename proto::result_of::eval<Expr const, Context>::type
|
||||
operator ()(Expr const &e) const
|
||||
{
|
||||
return proto::eval(e, this->ctx_);
|
||||
}
|
||||
|
||||
private:
|
||||
Context &ctx_;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename Context>
|
||||
struct is_callable<eval_fun<Context> >
|
||||
: mpl::true_
|
||||
{};
|
||||
}}
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
namespace extension
|
||||
{
|
||||
template<typename Tag>
|
||||
struct is_sequence_impl;
|
||||
|
||||
template<>
|
||||
struct is_sequence_impl<proto::tag::proto_flat_view>
|
||||
{
|
||||
template<typename Sequence>
|
||||
struct apply
|
||||
: mpl::true_
|
||||
{};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct is_sequence_impl<proto::tag::proto_expr>
|
||||
{
|
||||
template<typename Sequence>
|
||||
struct apply
|
||||
: mpl::true_
|
||||
{};
|
||||
};
|
||||
|
||||
template<typename Tag>
|
||||
struct is_view_impl;
|
||||
|
||||
template<>
|
||||
struct is_view_impl<proto::tag::proto_flat_view>
|
||||
{
|
||||
template<typename Sequence>
|
||||
struct apply
|
||||
: mpl::true_
|
||||
{};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct is_view_impl<proto::tag::proto_expr>
|
||||
{
|
||||
template<typename Sequence>
|
||||
struct apply
|
||||
: mpl::false_
|
||||
{};
|
||||
};
|
||||
|
||||
template<typename Tag>
|
||||
struct value_of_impl;
|
||||
|
||||
template<>
|
||||
struct value_of_impl<proto::tag::proto_expr_iterator>
|
||||
{
|
||||
template<
|
||||
typename Iterator
|
||||
, long Arity = proto::arity_of<typename Iterator::expr_type>::value
|
||||
>
|
||||
struct apply
|
||||
{
|
||||
typedef
|
||||
typename proto::result_of::child_c<
|
||||
typename Iterator::expr_type
|
||||
, Iterator::index
|
||||
>::value_type
|
||||
type;
|
||||
};
|
||||
|
||||
template<typename Iterator>
|
||||
struct apply<Iterator, 0>
|
||||
{
|
||||
typedef
|
||||
typename proto::result_of::value<
|
||||
typename Iterator::expr_type
|
||||
>::value_type
|
||||
type;
|
||||
};
|
||||
};
|
||||
|
||||
template<typename Tag>
|
||||
struct deref_impl;
|
||||
|
||||
template<>
|
||||
struct deref_impl<proto::tag::proto_expr_iterator>
|
||||
{
|
||||
template<
|
||||
typename Iterator
|
||||
, long Arity = proto::arity_of<typename Iterator::expr_type>::value
|
||||
>
|
||||
struct apply
|
||||
{
|
||||
typedef
|
||||
typename proto::result_of::child_c<
|
||||
typename Iterator::expr_type &
|
||||
, Iterator::index
|
||||
>::type
|
||||
type;
|
||||
|
||||
static type call(Iterator const &iter)
|
||||
{
|
||||
return proto::child_c<Iterator::index>(iter.expr);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Iterator>
|
||||
struct apply<Iterator, 0>
|
||||
{
|
||||
typedef
|
||||
typename proto::result_of::value<
|
||||
typename Iterator::expr_type &
|
||||
>::type
|
||||
type;
|
||||
|
||||
static type call(Iterator const &iter)
|
||||
{
|
||||
return proto::value(iter.expr);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template<typename Tag>
|
||||
struct advance_impl;
|
||||
|
||||
template<>
|
||||
struct advance_impl<proto::tag::proto_expr_iterator>
|
||||
{
|
||||
template<typename Iterator, typename N>
|
||||
struct apply
|
||||
{
|
||||
typedef
|
||||
typename proto::detail::expr_iterator<
|
||||
typename Iterator::expr_type
|
||||
, Iterator::index + N::value
|
||||
>
|
||||
type;
|
||||
|
||||
static type call(Iterator const &iter)
|
||||
{
|
||||
return type(iter.expr);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template<typename Tag>
|
||||
struct distance_impl;
|
||||
|
||||
template<>
|
||||
struct distance_impl<proto::tag::proto_expr_iterator>
|
||||
{
|
||||
template<typename IteratorFrom, typename IteratorTo>
|
||||
struct apply
|
||||
: mpl::long_<IteratorTo::index - IteratorFrom::index>
|
||||
{};
|
||||
};
|
||||
|
||||
template<typename Tag>
|
||||
struct next_impl;
|
||||
|
||||
template<>
|
||||
struct next_impl<proto::tag::proto_expr_iterator>
|
||||
{
|
||||
template<typename Iterator>
|
||||
struct apply
|
||||
: advance_impl<proto::tag::proto_expr_iterator>::template apply<Iterator, mpl::long_<1> >
|
||||
{};
|
||||
};
|
||||
|
||||
template<typename Tag>
|
||||
struct prior_impl;
|
||||
|
||||
template<>
|
||||
struct prior_impl<proto::tag::proto_expr_iterator>
|
||||
{
|
||||
template<typename Iterator>
|
||||
struct apply
|
||||
: advance_impl<proto::tag::proto_expr_iterator>::template apply<Iterator, mpl::long_<-1> >
|
||||
{};
|
||||
};
|
||||
|
||||
template<typename Tag>
|
||||
struct category_of_impl;
|
||||
|
||||
template<>
|
||||
struct category_of_impl<proto::tag::proto_expr>
|
||||
{
|
||||
template<typename Sequence>
|
||||
struct apply
|
||||
{
|
||||
typedef random_access_traversal_tag type;
|
||||
};
|
||||
};
|
||||
|
||||
template<typename Tag>
|
||||
struct size_impl;
|
||||
|
||||
template<>
|
||||
struct size_impl<proto::tag::proto_expr>
|
||||
{
|
||||
template<typename Sequence>
|
||||
struct apply
|
||||
: mpl::long_<0 == Sequence::proto_arity_c ? 1 : Sequence::proto_arity_c>
|
||||
{};
|
||||
};
|
||||
|
||||
template<typename Tag>
|
||||
struct begin_impl;
|
||||
|
||||
template<>
|
||||
struct begin_impl<proto::tag::proto_expr>
|
||||
{
|
||||
template<typename Sequence>
|
||||
struct apply
|
||||
{
|
||||
typedef proto::detail::expr_iterator<Sequence, 0> type;
|
||||
|
||||
static type call(Sequence &seq)
|
||||
{
|
||||
return type(seq);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template<typename Tag>
|
||||
struct end_impl;
|
||||
|
||||
template<>
|
||||
struct end_impl<proto::tag::proto_expr>
|
||||
{
|
||||
template<typename Sequence>
|
||||
struct apply
|
||||
{
|
||||
typedef
|
||||
proto::detail::expr_iterator<
|
||||
Sequence
|
||||
, 0 == Sequence::proto_arity_c ? 1 : Sequence::proto_arity_c
|
||||
>
|
||||
type;
|
||||
|
||||
static type call(Sequence &seq)
|
||||
{
|
||||
return type(seq);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template<typename Tag>
|
||||
struct value_at_impl;
|
||||
|
||||
template<>
|
||||
struct value_at_impl<proto::tag::proto_expr>
|
||||
{
|
||||
template<
|
||||
typename Sequence
|
||||
, typename Index
|
||||
, long Arity = proto::arity_of<Sequence>::value
|
||||
>
|
||||
struct apply
|
||||
{
|
||||
typedef
|
||||
typename proto::result_of::child_c<
|
||||
Sequence
|
||||
, Index::value
|
||||
>::value_type
|
||||
type;
|
||||
};
|
||||
|
||||
template<typename Sequence, typename Index>
|
||||
struct apply<Sequence, Index, 0>
|
||||
{
|
||||
typedef
|
||||
typename proto::result_of::value<
|
||||
Sequence
|
||||
>::value_type
|
||||
type;
|
||||
};
|
||||
};
|
||||
|
||||
template<typename Tag>
|
||||
struct at_impl;
|
||||
|
||||
template<>
|
||||
struct at_impl<proto::tag::proto_expr>
|
||||
{
|
||||
template<
|
||||
typename Sequence
|
||||
, typename Index
|
||||
, long Arity = proto::arity_of<Sequence>::value
|
||||
>
|
||||
struct apply
|
||||
{
|
||||
typedef
|
||||
typename proto::result_of::child_c<
|
||||
Sequence &
|
||||
, Index::value
|
||||
>::type
|
||||
type;
|
||||
|
||||
static type call(Sequence &seq)
|
||||
{
|
||||
return proto::child_c<Index::value>(seq);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Sequence, typename Index>
|
||||
struct apply<Sequence, Index, 0>
|
||||
{
|
||||
typedef
|
||||
typename proto::result_of::value<
|
||||
Sequence &
|
||||
>::type
|
||||
type;
|
||||
|
||||
static type call(Sequence &seq)
|
||||
{
|
||||
return proto::value(seq);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template<typename Tag>
|
||||
struct is_segmented_impl;
|
||||
|
||||
template<>
|
||||
struct is_segmented_impl<proto::tag::proto_flat_view>
|
||||
{
|
||||
template<typename Iterator>
|
||||
struct apply
|
||||
: mpl::true_
|
||||
{};
|
||||
};
|
||||
|
||||
template<typename Tag>
|
||||
struct segments_impl;
|
||||
|
||||
template<>
|
||||
struct segments_impl<proto::tag::proto_flat_view>
|
||||
{
|
||||
template<typename Sequence>
|
||||
struct apply
|
||||
{
|
||||
typedef typename Sequence::proto_tag proto_tag;
|
||||
|
||||
typedef fusion::transform_view<
|
||||
typename Sequence::expr_type
|
||||
, proto::detail::as_element<proto_tag>
|
||||
> type;
|
||||
|
||||
static type call(Sequence &sequence)
|
||||
{
|
||||
return type(sequence.expr_, proto::detail::as_element<proto_tag>());
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct category_of_impl<proto::tag::proto_flat_view>
|
||||
{
|
||||
template<typename Sequence>
|
||||
struct apply
|
||||
{
|
||||
typedef forward_traversal_tag type;
|
||||
};
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
namespace traits
|
||||
{
|
||||
template<typename Seq1, typename Seq2>
|
||||
struct enable_equality<
|
||||
Seq1
|
||||
, Seq2
|
||||
, typename enable_if_c<
|
||||
mpl::or_<
|
||||
proto::is_expr<Seq1>
|
||||
, proto::is_expr<Seq2>
|
||||
>::value
|
||||
>::type
|
||||
>
|
||||
: mpl::false_
|
||||
{};
|
||||
|
||||
template<typename Seq1, typename Seq2>
|
||||
struct enable_comparison<
|
||||
Seq1
|
||||
, Seq2
|
||||
, typename enable_if_c<
|
||||
mpl::or_<
|
||||
proto::is_expr<Seq1>
|
||||
, proto::is_expr<Seq2>
|
||||
>::value
|
||||
>::type
|
||||
>
|
||||
: mpl::false_
|
||||
{};
|
||||
}
|
||||
|
||||
}}
|
||||
|
||||
namespace boost { namespace mpl
|
||||
{
|
||||
template<typename Tag, typename Args, long Arity>
|
||||
struct sequence_tag< proto::expr<Tag, Args, Arity> >
|
||||
{
|
||||
typedef fusion::fusion_sequence_tag type;
|
||||
};
|
||||
|
||||
template<typename Tag, typename Args, long Arity>
|
||||
struct sequence_tag< proto::basic_expr<Tag, Args, Arity> >
|
||||
{
|
||||
typedef fusion::fusion_sequence_tag type;
|
||||
};
|
||||
}}
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
436
test/external/boost/proto/generate.hpp
vendored
Normal file
436
test/external/boost/proto/generate.hpp
vendored
Normal file
@@ -0,0 +1,436 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file generate.hpp
|
||||
/// Contains definition of generate\<\> class template, which end users can
|
||||
/// specialize for generating domain-specific expression wrappers.
|
||||
//
|
||||
// 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_GENERATE_HPP_EAN_02_13_2007
|
||||
#define BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/version.hpp>
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/iteration/iterate.hpp>
|
||||
#include <boost/preprocessor/facilities/intercept.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/utility/result_of.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/args.hpp>
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template<typename Expr>
|
||||
struct by_value_generator_;
|
||||
|
||||
template<typename Tag, typename Arg>
|
||||
struct by_value_generator_<proto::expr<Tag, term<Arg>, 0> >
|
||||
{
|
||||
typedef
|
||||
proto::expr<
|
||||
Tag
|
||||
, term<typename detail::term_traits<Arg>::value_type>
|
||||
, 0
|
||||
>
|
||||
type;
|
||||
|
||||
static type const call(proto::expr<Tag, term<Arg>, 0> const &e)
|
||||
{
|
||||
type that = {e.child0};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Tag, typename Arg>
|
||||
struct by_value_generator_<proto::basic_expr<Tag, term<Arg>, 0> >
|
||||
{
|
||||
typedef
|
||||
proto::basic_expr<
|
||||
Tag
|
||||
, term<typename detail::term_traits<Arg>::value_type>
|
||||
, 0
|
||||
>
|
||||
type;
|
||||
|
||||
static type const call(proto::basic_expr<Tag, term<Arg>, 0> const &e)
|
||||
{
|
||||
type that = {e.child0};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
// Include the other specializations of by_value_generator_
|
||||
#include <boost/proto/detail/generate_by_value.hpp>
|
||||
}
|
||||
|
||||
/// \brief Annotate a generator to indicate that it would
|
||||
/// prefer to be passed instances of \c proto::basic_expr\<\> rather
|
||||
/// than \c proto::expr\<\>. <tt>use_basic_expr\<Generator\></tt> is
|
||||
/// itself a generator.
|
||||
///
|
||||
template<typename Generator>
|
||||
struct use_basic_expr
|
||||
: Generator
|
||||
{
|
||||
BOOST_PROTO_USE_BASIC_EXPR()
|
||||
};
|
||||
|
||||
/// \brief A simple generator that passes an expression
|
||||
/// through unchanged.
|
||||
///
|
||||
/// Generators are intended for use as the first template parameter
|
||||
/// to the \c domain\<\> class template and control if and how
|
||||
/// expressions within that domain are to be customized.
|
||||
/// The \c default_generator makes no modifications to the expressions
|
||||
/// passed to it.
|
||||
struct default_generator
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr)>
|
||||
{
|
||||
typedef Expr type;
|
||||
};
|
||||
|
||||
/// \param expr A Proto expression
|
||||
/// \return expr
|
||||
template<typename Expr>
|
||||
#ifdef BOOST_PROTO_STRICT_RESULT_OF
|
||||
Expr
|
||||
#else
|
||||
Expr const &
|
||||
#endif
|
||||
operator ()(Expr const &e) const
|
||||
{
|
||||
return e;
|
||||
}
|
||||
};
|
||||
|
||||
/// \brief A simple generator that passes an expression
|
||||
/// through unchanged and specifies a preference for
|
||||
/// \c proto::basic_expr\<\> over \c proto::expr\<\>.
|
||||
///
|
||||
/// Generators are intended for use as the first template parameter
|
||||
/// to the \c domain\<\> class template and control if and how
|
||||
/// expressions within that domain are to be customized.
|
||||
/// The \c default_generator makes no modifications to the expressions
|
||||
/// passed to it.
|
||||
struct basic_default_generator
|
||||
: proto::use_basic_expr<default_generator>
|
||||
{};
|
||||
|
||||
/// \brief A generator that wraps expressions passed
|
||||
/// to it in the specified extension wrapper.
|
||||
///
|
||||
/// Generators are intended for use as the first template parameter
|
||||
/// to the \c domain\<\> class template and control if and how
|
||||
/// expressions within that domain are to be customized.
|
||||
/// \c generator\<\> wraps each expression passed to it in
|
||||
/// the \c Extends\<\> wrapper.
|
||||
template<template<typename> class Extends>
|
||||
struct generator
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
BOOST_PROTO_USE_BASIC_EXPR()
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr)>
|
||||
{
|
||||
typedef Extends<Expr> type;
|
||||
};
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr &)>
|
||||
{
|
||||
typedef Extends<Expr> type;
|
||||
};
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr const &)>
|
||||
{
|
||||
typedef Extends<Expr> type;
|
||||
};
|
||||
|
||||
/// \param expr A Proto expression
|
||||
/// \return Extends<Expr>(expr)
|
||||
template<typename Expr>
|
||||
Extends<Expr> operator ()(Expr const &e) const
|
||||
{
|
||||
return Extends<Expr>(e);
|
||||
}
|
||||
};
|
||||
|
||||
/// \brief A generator that wraps expressions passed
|
||||
/// to it in the specified extension wrapper and uses
|
||||
/// aggregate initialization for the wrapper.
|
||||
///
|
||||
/// Generators are intended for use as the first template parameter
|
||||
/// to the \c domain\<\> class template and control if and how
|
||||
/// expressions within that domain are to be customized.
|
||||
/// \c pod_generator\<\> wraps each expression passed to it in
|
||||
/// the \c Extends\<\> wrapper, and uses aggregate initialzation
|
||||
/// for the wrapped object.
|
||||
template<template<typename> class Extends>
|
||||
struct pod_generator
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
BOOST_PROTO_USE_BASIC_EXPR()
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr)>
|
||||
{
|
||||
typedef Extends<Expr> type;
|
||||
};
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr &)>
|
||||
{
|
||||
typedef Extends<Expr> type;
|
||||
};
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr const &)>
|
||||
{
|
||||
typedef Extends<Expr> type;
|
||||
};
|
||||
|
||||
/// \param expr The expression to wrap
|
||||
/// \return <tt>Extends\<Expr\> that = {expr}; return that;</tt>
|
||||
template<typename Expr>
|
||||
Extends<Expr> operator ()(Expr const &e) const
|
||||
{
|
||||
Extends<Expr> that = {e};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
/// \brief A generator that replaces child nodes held by
|
||||
/// reference with ones held by value. Use with
|
||||
/// \c compose_generators to forward that result to another
|
||||
/// generator.
|
||||
///
|
||||
/// Generators are intended for use as the first template parameter
|
||||
/// to the \c domain\<\> class template and control if and how
|
||||
/// expressions within that domain are to be customized.
|
||||
/// \c by_value_generator ensures all child nodes are
|
||||
/// held by value. This generator is typically composed with a
|
||||
/// second generator for further processing, as
|
||||
/// <tt>compose_generators\<by_value_generator, MyGenerator\></tt>.
|
||||
struct by_value_generator
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr)>
|
||||
{
|
||||
typedef
|
||||
typename detail::by_value_generator_<Expr>::type
|
||||
type;
|
||||
};
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr &)>
|
||||
{
|
||||
typedef
|
||||
typename detail::by_value_generator_<Expr>::type
|
||||
type;
|
||||
};
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr const &)>
|
||||
{
|
||||
typedef
|
||||
typename detail::by_value_generator_<Expr>::type
|
||||
type;
|
||||
};
|
||||
|
||||
/// \param expr The expression to modify.
|
||||
/// \return <tt>deep_copy(expr)</tt>
|
||||
template<typename Expr>
|
||||
typename result<by_value_generator(Expr)>::type operator ()(Expr const &e) const
|
||||
{
|
||||
return detail::by_value_generator_<Expr>::call(e);
|
||||
}
|
||||
};
|
||||
|
||||
/// \brief A composite generator that first applies one
|
||||
/// transform to an expression and then forwards the result
|
||||
/// on to another generator for further transformation.
|
||||
///
|
||||
/// Generators are intended for use as the first template parameter
|
||||
/// to the \c domain\<\> class template and control if and how
|
||||
/// expressions within that domain are to be customized.
|
||||
/// \c compose_generators\<\> is a composite generator that first
|
||||
/// applies one transform to an expression and then forwards the
|
||||
/// result on to another generator for further transformation.
|
||||
template<typename First, typename Second>
|
||||
struct compose_generators
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr)>
|
||||
{
|
||||
typedef
|
||||
typename Second::template result<
|
||||
Second(typename First::template result<First(Expr)>::type)
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr &)>
|
||||
{
|
||||
typedef
|
||||
typename Second::template result<
|
||||
Second(typename First::template result<First(Expr)>::type)
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
template<typename This, typename Expr>
|
||||
struct result<This(Expr const &)>
|
||||
{
|
||||
typedef
|
||||
typename Second::template result<
|
||||
Second(typename First::template result<First(Expr)>::type)
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
/// \param expr The expression to modify.
|
||||
/// \return Second()(First()(expr))
|
||||
template<typename Expr>
|
||||
typename result<compose_generators(Expr)>::type operator ()(Expr const &e) const
|
||||
{
|
||||
return Second()(First()(e));
|
||||
}
|
||||
};
|
||||
|
||||
/// \brief Tests a generator to see whether it would prefer
|
||||
/// to be passed instances of \c proto::basic_expr\<\> rather than
|
||||
/// \c proto::expr\<\>.
|
||||
///
|
||||
template<typename Generator, typename Void>
|
||||
struct wants_basic_expr
|
||||
: mpl::false_
|
||||
{};
|
||||
|
||||
template<typename Generator>
|
||||
struct wants_basic_expr<Generator, typename Generator::proto_use_basic_expr_>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<>
|
||||
struct is_callable<default_generator>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<template<typename> class Extends>
|
||||
struct is_callable<generator<Extends> >
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<template<typename> class Extends>
|
||||
struct is_callable<pod_generator<Extends> >
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<>
|
||||
struct is_callable<by_value_generator>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<typename First, typename Second>
|
||||
struct is_callable<compose_generators<First, Second> >
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
}}
|
||||
|
||||
// Specializations of boost::result_of and boost::tr1_result_of to eliminate
|
||||
// some unnecessary template instantiations
|
||||
namespace boost
|
||||
{
|
||||
template<typename Expr>
|
||||
struct result_of<proto::default_domain(Expr)>
|
||||
{
|
||||
typedef Expr type;
|
||||
};
|
||||
|
||||
template<typename Expr>
|
||||
struct result_of<proto::basic_default_domain(Expr)>
|
||||
{
|
||||
typedef Expr type;
|
||||
};
|
||||
|
||||
template<typename Expr>
|
||||
struct result_of<proto::default_generator(Expr)>
|
||||
{
|
||||
typedef Expr type;
|
||||
};
|
||||
|
||||
template<typename Expr>
|
||||
struct result_of<proto::basic_default_generator(Expr)>
|
||||
{
|
||||
typedef Expr type;
|
||||
};
|
||||
|
||||
#if BOOST_VERSION >= 104400
|
||||
template<typename Expr>
|
||||
struct tr1_result_of<proto::default_domain(Expr)>
|
||||
{
|
||||
typedef Expr type;
|
||||
};
|
||||
|
||||
template<typename Expr>
|
||||
struct tr1_result_of<proto::basic_default_domain(Expr)>
|
||||
{
|
||||
typedef Expr type;
|
||||
};
|
||||
|
||||
template<typename Expr>
|
||||
struct tr1_result_of<proto::default_generator(Expr)>
|
||||
{
|
||||
typedef Expr type;
|
||||
};
|
||||
|
||||
template<typename Expr>
|
||||
struct tr1_result_of<proto::basic_default_generator(Expr)>
|
||||
{
|
||||
typedef Expr type;
|
||||
};
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif // BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007
|
||||
112
test/external/boost/proto/literal.hpp
vendored
Normal file
112
test/external/boost/proto/literal.hpp
vendored
Normal file
@@ -0,0 +1,112 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file literal.hpp
|
||||
/// The literal\<\> terminal wrapper, and the proto::lit() function for
|
||||
/// creating literal\<\> wrappers.
|
||||
//
|
||||
// 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_LITERAL_HPP_EAN_01_03_2007
|
||||
#define BOOST_PROTO_LITERAL_HPP_EAN_01_03_2007
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/expr.hpp>
|
||||
#include <boost/proto/traits.hpp>
|
||||
#include <boost/proto/extends.hpp>
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
namespace utility
|
||||
{
|
||||
/// \brief A simple wrapper for a terminal, provided for
|
||||
/// ease of use.
|
||||
///
|
||||
/// A simple wrapper for a terminal, provided for
|
||||
/// ease of use. In all cases, <tt>literal\<X\> l(x);</tt>
|
||||
/// is equivalent to <tt>terminal\<X\>::type l = {x};</tt>.
|
||||
///
|
||||
/// The \c Domain template parameter defaults to
|
||||
/// \c proto::default_domain.
|
||||
template<
|
||||
typename T
|
||||
, typename Domain // = default_domain
|
||||
>
|
||||
struct literal
|
||||
: extends<basic_expr<tag::terminal, term<T>, 0>, literal<T, Domain>, Domain>
|
||||
{
|
||||
private:
|
||||
typedef basic_expr<tag::terminal, term<T>, 0> terminal_type;
|
||||
typedef extends<terminal_type, literal<T, Domain>, Domain> base_type;
|
||||
typedef literal<T, Domain> literal_t;
|
||||
|
||||
public:
|
||||
typedef typename detail::term_traits<T>::value_type value_type;
|
||||
typedef typename detail::term_traits<T>::reference reference;
|
||||
typedef typename detail::term_traits<T>::const_reference const_reference;
|
||||
|
||||
literal()
|
||||
: base_type(terminal_type::make(T()))
|
||||
{}
|
||||
|
||||
template<typename U>
|
||||
literal(U &u)
|
||||
: base_type(terminal_type::make(u))
|
||||
{}
|
||||
|
||||
template<typename U>
|
||||
literal(U const &u)
|
||||
: base_type(terminal_type::make(u))
|
||||
{}
|
||||
|
||||
template<typename U>
|
||||
literal(literal<U, Domain> const &u)
|
||||
: base_type(terminal_type::make(u.get()))
|
||||
{}
|
||||
|
||||
BOOST_PROTO_EXTENDS_USING_ASSIGN(literal_t)
|
||||
|
||||
reference get()
|
||||
{
|
||||
return proto::value(*this);
|
||||
}
|
||||
|
||||
const_reference get() const
|
||||
{
|
||||
return proto::value(*this);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/// \brief A helper function for creating a \c literal\<\> wrapper.
|
||||
/// \param t The object to wrap.
|
||||
/// \return literal\<T &\>(t)
|
||||
/// \attention The returned value holds the argument by reference.
|
||||
/// \throw nothrow
|
||||
template<typename T>
|
||||
inline literal<T &> const lit(T &t)
|
||||
{
|
||||
return literal<T &>(t);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
///
|
||||
template<typename T>
|
||||
inline literal<T const &> const lit(T const &t)
|
||||
{
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable: 4180) // warning C4180: qualifier applied to function type has no meaning; ignored
|
||||
#endif
|
||||
|
||||
return literal<T const &>(t);
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
}
|
||||
|
||||
}}
|
||||
|
||||
#endif
|
||||
502
test/external/boost/proto/make_expr.hpp
vendored
Normal file
502
test/external/boost/proto/make_expr.hpp
vendored
Normal file
@@ -0,0 +1,502 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file make_expr.hpp
|
||||
/// Definition of the \c make_expr() and \c unpack_expr() utilities for
|
||||
/// building Proto expression nodes from child nodes or from a Fusion
|
||||
/// sequence of child nodes, respectively.
|
||||
//
|
||||
// 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_MAKE_EXPR_HPP_EAN_04_01_2005
|
||||
#define BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005
|
||||
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/arithmetic/inc.hpp>
|
||||
#include <boost/preprocessor/arithmetic/dec.hpp>
|
||||
#include <boost/preprocessor/arithmetic/sub.hpp>
|
||||
#include <boost/preprocessor/punctuation/comma_if.hpp>
|
||||
#include <boost/preprocessor/iteration/iterate.hpp>
|
||||
#include <boost/preprocessor/facilities/intercept.hpp>
|
||||
#include <boost/preprocessor/repetition/enum.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/mpl/assert.hpp>
|
||||
#include <boost/mpl/eval_if.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/type_traits/add_const.hpp>
|
||||
#include <boost/type_traits/add_reference.hpp>
|
||||
#include <boost/type_traits/remove_cv.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/traits.hpp>
|
||||
#include <boost/proto/domain.hpp>
|
||||
#include <boost/proto/generate.hpp>
|
||||
#include <boost/fusion/include/at_c.hpp>
|
||||
#include <boost/fusion/include/begin.hpp>
|
||||
#include <boost/fusion/include/next.hpp>
|
||||
#include <boost/fusion/include/value_of.hpp>
|
||||
#include <boost/fusion/include/size.hpp>
|
||||
#include <boost/proto/detail/poly_function.hpp>
|
||||
#include <boost/proto/detail/deprecated.hpp>
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable: 4180) // qualifier applied to function type has no meaning; ignored
|
||||
#endif
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_AS_CHILD_TYPE(Z, N, DATA) \
|
||||
typename boost::proto::detail::protoify< \
|
||||
BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 0, DATA), N) \
|
||||
, BOOST_PP_TUPLE_ELEM(3, 2, DATA) \
|
||||
>::result_type \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_AS_CHILD(Z, N, DATA) \
|
||||
boost::proto::detail::protoify< \
|
||||
BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 0, DATA), N) \
|
||||
, BOOST_PP_TUPLE_ELEM(3, 2, DATA) \
|
||||
>()(BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 1, DATA), N)) \
|
||||
/**/
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template<typename T, typename Domain>
|
||||
struct protoify
|
||||
: Domain::template as_expr<T>
|
||||
{};
|
||||
|
||||
template<typename T, typename Domain>
|
||||
struct protoify<T &, Domain>
|
||||
: Domain::template as_child<T>
|
||||
{};
|
||||
|
||||
template<typename T, typename Domain>
|
||||
struct protoify<boost::reference_wrapper<T>, Domain>
|
||||
: Domain::template as_child<T>
|
||||
{};
|
||||
|
||||
template<typename T, typename Domain>
|
||||
struct protoify<boost::reference_wrapper<T> const, Domain>
|
||||
: Domain::template as_child<T>
|
||||
{};
|
||||
|
||||
// Definition of detail::unpack_expr_
|
||||
#include <boost/proto/detail/unpack_expr_.hpp>
|
||||
|
||||
// Definition of detail::make_expr_
|
||||
#include <boost/proto/detail/make_expr_.hpp>
|
||||
}
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
/// \brief Metafunction that computes the return type of the
|
||||
/// \c make_expr() function, with a domain deduced from the
|
||||
/// domains of the children.
|
||||
///
|
||||
/// Use the <tt>result_of::make_expr\<\></tt> metafunction to
|
||||
/// compute the return type of the \c make_expr() function.
|
||||
///
|
||||
/// In this specialization, the domain is deduced from the
|
||||
/// domains of the child types. (If
|
||||
/// <tt>is_domain\<A0\>::value</tt> is \c true, then another
|
||||
/// specialization is selected.)
|
||||
template<
|
||||
typename Tag
|
||||
, BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_ARITY, typename A)
|
||||
, typename Void1 // = void
|
||||
, typename Void2 // = void
|
||||
>
|
||||
struct make_expr
|
||||
{
|
||||
/// Same as <tt>result_of::make_expr\<Tag, D, A0, ... AN\>::type</tt>
|
||||
/// where \c D is the deduced domain, which is calculated as follows:
|
||||
///
|
||||
/// For each \c x in <tt>[0,N)</tt> (proceeding in order beginning with
|
||||
/// <tt>x=0</tt>), if <tt>domain_of\<Ax\>::type</tt> is not
|
||||
/// \c default_domain, then \c D is <tt>domain_of\<Ax\>::type</tt>.
|
||||
/// Otherwise, \c D is \c default_domain.
|
||||
typedef
|
||||
typename detail::make_expr_<
|
||||
Tag
|
||||
, deduce_domain
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A)
|
||||
>::result_type
|
||||
type;
|
||||
};
|
||||
|
||||
/// \brief Metafunction that computes the return type of the
|
||||
/// \c make_expr() function, within the specified domain.
|
||||
///
|
||||
/// Use the <tt>result_of::make_expr\<\></tt> metafunction to compute
|
||||
/// the return type of the \c make_expr() function.
|
||||
template<
|
||||
typename Tag
|
||||
, typename Domain
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, typename A)
|
||||
>
|
||||
struct make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A)
|
||||
, typename Domain::proto_is_domain_
|
||||
>
|
||||
{
|
||||
/// If \c Tag is <tt>tag::terminal</tt>, then \c type is a
|
||||
/// typedef for <tt>boost::result_of\<Domain(expr\<tag::terminal,
|
||||
/// term\<A0\> \>)\>::type</tt>.
|
||||
///
|
||||
/// Otherwise, \c type is a typedef for <tt>boost::result_of\<Domain(expr\<Tag,
|
||||
/// listN\< as_child\<A0\>::type, ... as_child\<AN\>::type\>)
|
||||
/// \>::type</tt>, where \c N is the number of non-void template
|
||||
/// arguments, and <tt>as_child\<A\>::type</tt> is evaluated as
|
||||
/// follows:
|
||||
///
|
||||
/// \li If <tt>is_expr\<A\>::value</tt> is \c true, then the
|
||||
/// child type is \c A.
|
||||
/// \li If \c A is <tt>B &</tt> or <tt>cv boost::reference_wrapper\<B\></tt>,
|
||||
/// and <tt>is_expr\<B\>::value</tt> is \c true, then the
|
||||
/// child type is <tt>B &</tt>.
|
||||
/// \li If <tt>is_expr\<A\>::value</tt> is \c false, then the
|
||||
/// child type is <tt>boost::result_of\<Domain(expr\<tag::terminal, term\<A\> \>
|
||||
/// )\>::type</tt>.
|
||||
/// \li If \c A is <tt>B &</tt> or <tt>cv boost::reference_wrapper\<B\></tt>,
|
||||
/// and <tt>is_expr\<B\>::value</tt> is \c false, then the
|
||||
/// child type is <tt>boost::result_of\<Domain(expr\<tag::terminal, term\<B &\> \>
|
||||
/// )\>::type</tt>.
|
||||
typedef
|
||||
typename detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A)
|
||||
>::result_type
|
||||
type;
|
||||
};
|
||||
|
||||
/// \brief Metafunction that computes the return type of the
|
||||
/// \c unpack_expr() function, with a domain deduced from the
|
||||
/// domains of the children.
|
||||
///
|
||||
/// Use the <tt>result_of::unpack_expr\<\></tt> metafunction to
|
||||
/// compute the return type of the \c unpack_expr() function.
|
||||
///
|
||||
/// \c Sequence is a Fusion Forward Sequence.
|
||||
///
|
||||
/// In this specialization, the domain is deduced from the
|
||||
/// domains of the child types. (If
|
||||
/// <tt>is_domain\<Sequence>::value</tt> is \c true, then another
|
||||
/// specialization is selected.)
|
||||
template<
|
||||
typename Tag
|
||||
, typename Sequence
|
||||
, typename Void1 // = void
|
||||
, typename Void2 // = void
|
||||
>
|
||||
struct unpack_expr
|
||||
{
|
||||
/// Let \c S be the type of a Fusion Random Access Sequence
|
||||
/// equivalent to \c Sequence. Then \c type is the
|
||||
/// same as <tt>result_of::make_expr\<Tag,
|
||||
/// fusion::result_of::value_at_c\<S, 0\>::type, ...
|
||||
/// fusion::result_of::value_at_c\<S, N-1\>::type\>::type</tt>,
|
||||
/// where \c N is the size of \c S.
|
||||
typedef
|
||||
typename detail::unpack_expr_<
|
||||
Tag
|
||||
, deduce_domain
|
||||
, Sequence
|
||||
, fusion::result_of::size<Sequence>::type::value
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
/// \brief Metafunction that computes the return type of the
|
||||
/// \c unpack_expr() function, within the specified domain.
|
||||
///
|
||||
/// Use the <tt>result_of::make_expr\<\></tt> metafunction to compute
|
||||
/// the return type of the \c make_expr() function.
|
||||
template<typename Tag, typename Domain, typename Sequence>
|
||||
struct unpack_expr<Tag, Domain, Sequence, typename Domain::proto_is_domain_>
|
||||
{
|
||||
/// Let \c S be the type of a Fusion Random Access Sequence
|
||||
/// equivalent to \c Sequence. Then \c type is the
|
||||
/// same as <tt>result_of::make_expr\<Tag, Domain,
|
||||
/// fusion::result_of::value_at_c\<S, 0\>::type, ...
|
||||
/// fusion::result_of::value_at_c\<S, N-1\>::type\>::type</tt>,
|
||||
/// where \c N is the size of \c S.
|
||||
typedef
|
||||
typename detail::unpack_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, Sequence
|
||||
, fusion::result_of::size<Sequence>::type::value
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
}
|
||||
|
||||
namespace functional
|
||||
{
|
||||
/// \brief A callable function object equivalent to the
|
||||
/// \c proto::make_expr() function.
|
||||
///
|
||||
/// In all cases, <tt>functional::make_expr\<Tag, Domain\>()(a0, ... aN)</tt>
|
||||
/// is equivalent to <tt>proto::make_expr\<Tag, Domain\>(a0, ... aN)</tt>.
|
||||
///
|
||||
/// <tt>functional::make_expr\<Tag\>()(a0, ... aN)</tt>
|
||||
/// is equivalent to <tt>proto::make_expr\<Tag\>(a0, ... aN)</tt>.
|
||||
template<typename Tag, typename Domain /* = deduce_domain*/>
|
||||
struct make_expr
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
BOOST_PROTO_POLY_FUNCTION()
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename A0>
|
||||
struct result<This(A0)>
|
||||
{
|
||||
typedef
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, A0
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
/// Construct an expression node with tag type \c Tag
|
||||
/// and in the domain \c Domain.
|
||||
///
|
||||
/// \return <tt>proto::make_expr\<Tag, Domain\>(a0,...aN)</tt>
|
||||
template<typename A0>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, A0 const
|
||||
>::type const
|
||||
operator ()(A0 const &a0) const
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, A0 const
|
||||
>()(a0);
|
||||
}
|
||||
|
||||
// Additional overloads generated by the preprocessor ...
|
||||
#include <boost/proto/detail/make_expr_funop.hpp>
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<
|
||||
BOOST_PP_ENUM_BINARY_PARAMS(
|
||||
BOOST_PROTO_MAX_ARITY
|
||||
, typename A
|
||||
, = void BOOST_PP_INTERCEPT
|
||||
)
|
||||
>
|
||||
struct impl
|
||||
: detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A)
|
||||
>
|
||||
{};
|
||||
};
|
||||
|
||||
/// \brief A callable function object equivalent to the
|
||||
/// \c proto::unpack_expr() function.
|
||||
///
|
||||
/// In all cases, <tt>functional::unpack_expr\<Tag, Domain\>()(seq)</tt>
|
||||
/// is equivalent to <tt>proto::unpack_expr\<Tag, Domain\>(seq)</tt>.
|
||||
///
|
||||
/// <tt>functional::unpack_expr\<Tag\>()(seq)</tt>
|
||||
/// is equivalent to <tt>proto::unpack_expr\<Tag\>(seq)</tt>.
|
||||
template<typename Tag, typename Domain /* = deduce_domain*/>
|
||||
struct unpack_expr
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
|
||||
template<typename This, typename Sequence>
|
||||
struct result<This(Sequence)>
|
||||
{
|
||||
typedef
|
||||
typename result_of::unpack_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, typename remove_reference<Sequence>::type
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
/// Construct an expression node with tag type \c Tag
|
||||
/// and in the domain \c Domain.
|
||||
///
|
||||
/// \param sequence A Fusion Forward Sequence
|
||||
/// \return <tt>proto::unpack_expr\<Tag, Domain\>(sequence)</tt>
|
||||
template<typename Sequence>
|
||||
typename result_of::unpack_expr<Tag, Domain, Sequence const>::type const
|
||||
operator ()(Sequence const &sequence) const
|
||||
{
|
||||
return proto::detail::unpack_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, Sequence const
|
||||
, fusion::result_of::size<Sequence>::type::value
|
||||
>::call(sequence);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace functional
|
||||
|
||||
/// \brief Construct an expression of the requested tag type
|
||||
/// with a domain and with the specified arguments as children.
|
||||
///
|
||||
/// This function template may be invoked either with or without
|
||||
/// specifying a \c Domain argument. If no domain is specified,
|
||||
/// the domain is deduced by examining in order the domains of
|
||||
/// the given arguments and taking the first that is not
|
||||
/// \c default_domain, if any such domain exists, or
|
||||
/// \c default_domain otherwise.
|
||||
///
|
||||
/// Let \c wrap_(x) be defined such that:
|
||||
/// \li If \c x is a <tt>boost::reference_wrapper\<\></tt>,
|
||||
/// \c wrap_(x) is equivalent to <tt>as_child\<Domain\>(x.get())</tt>.
|
||||
/// \li Otherwise, \c wrap_(x) is equivalent to
|
||||
/// <tt>as_expr\<Domain\>(x)</tt>.
|
||||
///
|
||||
/// Let <tt>make_\<Tag\>(b0,...bN)</tt> be defined as
|
||||
/// <tt>expr\<Tag, listN\<C0,...CN\> \>::make(c0,...cN)</tt>
|
||||
/// where \c Bx is the type of \c bx.
|
||||
///
|
||||
/// \return <tt>Domain()(make_\<Tag\>(wrap_(a0),...wrap_(aN)))</tt>.
|
||||
template<typename Tag, typename A0>
|
||||
typename lazy_disable_if<
|
||||
is_domain<A0>
|
||||
, result_of::make_expr<
|
||||
Tag
|
||||
, A0 const
|
||||
>
|
||||
>::type const
|
||||
make_expr(A0 const &a0)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, deduce_domain
|
||||
, A0 const
|
||||
>()(a0);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
///
|
||||
template<typename Tag, typename Domain, typename C0>
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
, C0 const
|
||||
>::type const
|
||||
make_expr(C0 const &c0)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, C0 const
|
||||
>()(c0);
|
||||
}
|
||||
|
||||
// Additional overloads generated by the preprocessor...
|
||||
#include <boost/proto/detail/make_expr.hpp>
|
||||
|
||||
/// \brief Construct an expression of the requested tag type
|
||||
/// with a domain and with childres from the specified Fusion
|
||||
/// Forward Sequence.
|
||||
///
|
||||
/// This function template may be invoked either with or without
|
||||
/// specifying a \c Domain argument. If no domain is specified,
|
||||
/// the domain is deduced by examining in order the domains of the
|
||||
/// elements of \c sequence and taking the first that is not
|
||||
/// \c default_domain, if any such domain exists, or
|
||||
/// \c default_domain otherwise.
|
||||
///
|
||||
/// Let \c s be a Fusion Random Access Sequence equivalent to \c sequence.
|
||||
/// Let <tt>wrap_\<N\>(s)</tt>, where \c s has type \c S, be defined
|
||||
/// such that:
|
||||
/// \li If <tt>fusion::result_of::value_at_c\<S,N\>::type</tt> is a reference,
|
||||
/// <tt>wrap_\<N\>(s)</tt> is equivalent to
|
||||
/// <tt>as_child\<Domain\>(fusion::at_c\<N\>(s))</tt>.
|
||||
/// \li Otherwise, <tt>wrap_\<N\>(s)</tt> is equivalent to
|
||||
/// <tt>as_expr\<Domain\>(fusion::at_c\<N\>(s))</tt>.
|
||||
///
|
||||
/// Let <tt>make_\<Tag\>(b0,...bN)</tt> be defined as
|
||||
/// <tt>expr\<Tag, listN\<B0,...BN\> \>::make(b0,...bN)</tt>
|
||||
/// where \c Bx is the type of \c bx.
|
||||
///
|
||||
/// \param sequence a Fusion Forward Sequence.
|
||||
/// \return <tt>Domain()(make_\<Tag\>(wrap_\<0\>(s),...wrap_\<N-1\>(s)))</tt>,
|
||||
/// where N is the size of \c Sequence.
|
||||
template<typename Tag, typename Sequence>
|
||||
typename lazy_disable_if<
|
||||
is_domain<Sequence>
|
||||
, result_of::unpack_expr<Tag, Sequence const>
|
||||
>::type const
|
||||
unpack_expr(Sequence const &sequence)
|
||||
{
|
||||
return proto::detail::unpack_expr_<
|
||||
Tag
|
||||
, deduce_domain
|
||||
, Sequence const
|
||||
, fusion::result_of::size<Sequence>::type::value
|
||||
>::call(sequence);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
///
|
||||
template<typename Tag, typename Domain, typename Sequence2>
|
||||
typename result_of::unpack_expr<Tag, Domain, Sequence2 const>::type const
|
||||
unpack_expr(Sequence2 const &sequence2)
|
||||
{
|
||||
return proto::detail::unpack_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
, Sequence2 const
|
||||
, fusion::result_of::size<Sequence2>::type::value
|
||||
>::call(sequence2);
|
||||
}
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename Tag, typename Domain>
|
||||
struct is_callable<functional::make_expr<Tag, Domain> >
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename Tag, typename Domain>
|
||||
struct is_callable<functional::unpack_expr<Tag, Domain> >
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
}}
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005
|
||||
951
test/external/boost/proto/matches.hpp
vendored
Normal file
951
test/external/boost/proto/matches.hpp
vendored
Normal file
@@ -0,0 +1,951 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file matches.hpp
|
||||
/// Contains definition of matches\<\> metafunction for determining if
|
||||
/// a given expression matches a given pattern.
|
||||
//
|
||||
// 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_MATCHES_HPP_EAN_11_03_2006
|
||||
#define BOOST_PROTO_MATCHES_HPP_EAN_11_03_2006
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/arithmetic/dec.hpp>
|
||||
#include <boost/preprocessor/arithmetic/sub.hpp>
|
||||
#include <boost/preprocessor/iteration/iterate.hpp>
|
||||
#include <boost/preprocessor/facilities/intercept.hpp>
|
||||
#include <boost/preprocessor/punctuation/comma_if.hpp>
|
||||
#include <boost/preprocessor/repetition/enum.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_shifted.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/mpl/logical.hpp>
|
||||
#include <boost/mpl/eval_if.hpp>
|
||||
#include <boost/proto/detail/template_arity.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
|
||||
#include <boost/type_traits/is_array.hpp>
|
||||
#endif
|
||||
#include <boost/type_traits/is_const.hpp>
|
||||
#include <boost/type_traits/is_convertible.hpp>
|
||||
#include <boost/type_traits/is_reference.hpp>
|
||||
#include <boost/type_traits/is_pointer.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/traits.hpp>
|
||||
#include <boost/proto/transform/when.hpp>
|
||||
#include <boost/proto/transform/impl.hpp>
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable:4305) // 'specialization' : truncation from 'const int' to 'bool'
|
||||
#endif
|
||||
|
||||
#define BOOST_PROTO_LOGICAL_typename_G BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G)
|
||||
#define BOOST_PROTO_LOGICAL_G BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, G)
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template<typename Expr, typename BasicExpr, typename Grammar>
|
||||
struct matches_;
|
||||
|
||||
template<bool B, typename Pred>
|
||||
struct and_2;
|
||||
|
||||
template<typename And, typename Expr, typename State, typename Data>
|
||||
struct _and_impl;
|
||||
|
||||
template<typename T, typename U>
|
||||
struct array_matches
|
||||
: mpl::false_
|
||||
{};
|
||||
|
||||
template<typename T, std::size_t M>
|
||||
struct array_matches<T[M], T *>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
template<typename T, std::size_t M>
|
||||
struct array_matches<T[M], T const *>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
template<typename T, std::size_t M>
|
||||
struct array_matches<T[M], T[proto::N]>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
template<typename T, typename U
|
||||
BOOST_PROTO_TEMPLATE_ARITY_PARAM(long Arity = detail::template_arity<U>::value)
|
||||
>
|
||||
struct lambda_matches
|
||||
: mpl::false_
|
||||
{};
|
||||
|
||||
template<typename T>
|
||||
struct lambda_matches<T, proto::_ BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
template<typename T>
|
||||
struct lambda_matches<T, T BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
template<typename T, std::size_t M, typename U>
|
||||
struct lambda_matches<T[M], U BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)>
|
||||
: array_matches<T[M], U>
|
||||
{};
|
||||
|
||||
template<typename T, std::size_t M>
|
||||
struct lambda_matches<T[M], _ BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
template<typename T, std::size_t M>
|
||||
struct lambda_matches<T[M], T[M] BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
template<template<typename> class T, typename Expr0, typename Grammar0>
|
||||
struct lambda_matches<T<Expr0>, T<Grammar0> BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) >
|
||||
: lambda_matches<Expr0, Grammar0>
|
||||
{};
|
||||
|
||||
// vararg_matches_impl
|
||||
template<typename Args1, typename Back, long From, long To>
|
||||
struct vararg_matches_impl;
|
||||
|
||||
// vararg_matches
|
||||
template<typename Expr, typename Args1, typename Args2, typename Back, bool Can, bool Zero, typename Void = void>
|
||||
struct vararg_matches
|
||||
: mpl::false_
|
||||
{};
|
||||
|
||||
template<typename Expr, typename Args1, typename Args2, typename Back>
|
||||
struct vararg_matches<Expr, Args1, Args2, Back, true, true, typename Back::proto_is_vararg_>
|
||||
: matches_<
|
||||
Expr
|
||||
, proto::basic_expr<ignore, Args1, Args1::arity>
|
||||
, proto::basic_expr<ignore, Args2, Args1::arity>
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename Args1, typename Args2, typename Back>
|
||||
struct vararg_matches<Expr, Args1, Args2, Back, true, false, typename Back::proto_is_vararg_>
|
||||
: and_2<
|
||||
matches_<
|
||||
Expr
|
||||
, proto::basic_expr<ignore, Args1, Args2::arity>
|
||||
, proto::basic_expr<ignore, Args2, Args2::arity>
|
||||
>::value
|
||||
, vararg_matches_impl<Args1, typename Back::proto_grammar, Args2::arity + 1, Args1::arity>
|
||||
>
|
||||
{};
|
||||
|
||||
// How terminal_matches<> handles references and cv-qualifiers.
|
||||
// The cv and ref matter *only* if the grammar has a top-level ref.
|
||||
//
|
||||
// Expr | Grammar | Matches?
|
||||
// -------------------------------------
|
||||
// T T yes
|
||||
// T & T yes
|
||||
// T const & T yes
|
||||
// T T & no
|
||||
// T & T & yes
|
||||
// T const & T & no
|
||||
// T T const & no
|
||||
// T & T const & no
|
||||
// T const & T const & yes
|
||||
|
||||
template<typename T, typename U>
|
||||
struct is_cv_ref_compatible
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
template<typename T, typename U>
|
||||
struct is_cv_ref_compatible<T, U &>
|
||||
: mpl::false_
|
||||
{};
|
||||
|
||||
template<typename T, typename U>
|
||||
struct is_cv_ref_compatible<T &, U &>
|
||||
: mpl::bool_<is_const<T>::value == is_const<U>::value>
|
||||
{};
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
|
||||
// MSVC-7.1 has lots of problems with array types that have been
|
||||
// deduced. Partially specializing terminal_matches<> on array types
|
||||
// doesn't seem to work.
|
||||
template<
|
||||
typename T
|
||||
, typename U
|
||||
, bool B = is_array<BOOST_PROTO_UNCVREF(T)>::value
|
||||
>
|
||||
struct terminal_array_matches
|
||||
: mpl::false_
|
||||
{};
|
||||
|
||||
template<typename T, typename U, std::size_t M>
|
||||
struct terminal_array_matches<T, U(&)[M], true>
|
||||
: is_convertible<T, U(&)[M]>
|
||||
{};
|
||||
|
||||
template<typename T, typename U>
|
||||
struct terminal_array_matches<T, U(&)[proto::N], true>
|
||||
: is_convertible<T, U *>
|
||||
{};
|
||||
|
||||
template<typename T, typename U>
|
||||
struct terminal_array_matches<T, U *, true>
|
||||
: is_convertible<T, U *>
|
||||
{};
|
||||
|
||||
// terminal_matches
|
||||
template<typename T, typename U>
|
||||
struct terminal_matches
|
||||
: mpl::or_<
|
||||
mpl::and_<
|
||||
is_cv_ref_compatible<T, U>
|
||||
, lambda_matches<
|
||||
BOOST_PROTO_UNCVREF(T)
|
||||
, BOOST_PROTO_UNCVREF(U)
|
||||
>
|
||||
>
|
||||
, terminal_array_matches<T, U>
|
||||
>
|
||||
{};
|
||||
#else
|
||||
// terminal_matches
|
||||
template<typename T, typename U>
|
||||
struct terminal_matches
|
||||
: mpl::and_<
|
||||
is_cv_ref_compatible<T, U>
|
||||
, lambda_matches<
|
||||
BOOST_PROTO_UNCVREF(T)
|
||||
, BOOST_PROTO_UNCVREF(U)
|
||||
>
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename T, std::size_t M>
|
||||
struct terminal_matches<T(&)[M], T(&)[proto::N]>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
template<typename T, std::size_t M>
|
||||
struct terminal_matches<T(&)[M], T *>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
// Avoid ambiguity errors on MSVC
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
|
||||
template<typename T, std::size_t M>
|
||||
struct terminal_matches<T const (&)[M], T const[M]>
|
||||
: mpl::true_
|
||||
{};
|
||||
#endif
|
||||
#endif
|
||||
|
||||
template<typename T>
|
||||
struct terminal_matches<T, T>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
template<typename T>
|
||||
struct terminal_matches<T &, T>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
template<typename T>
|
||||
struct terminal_matches<T const &, T>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
template<typename T>
|
||||
struct terminal_matches<T, proto::_>
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
template<typename T>
|
||||
struct terminal_matches<T, exact<T> >
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
template<typename T, typename U>
|
||||
struct terminal_matches<T, proto::convertible_to<U> >
|
||||
: is_convertible<T, U>
|
||||
{};
|
||||
|
||||
// matches_
|
||||
template<typename Expr, typename BasicExpr, typename Grammar>
|
||||
struct matches_
|
||||
: mpl::false_
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr>
|
||||
struct matches_< Expr, BasicExpr, proto::_ >
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
template<typename Expr, typename Tag, typename Args1, long N1, typename Args2, long N2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, N1>, proto::basic_expr<Tag, Args2, N2> >
|
||||
: vararg_matches< Expr, Args1, Args2, typename Args2::back_, (N1+2 > N2), (N2 > N1) >
|
||||
{};
|
||||
|
||||
template<typename Expr, typename Tag, typename Args1, long N1, typename Args2, long N2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, N1>, proto::basic_expr<proto::_, Args2, N2> >
|
||||
: vararg_matches< Expr, Args1, Args2, typename Args2::back_, (N1+2 > N2), (N2 > N1) >
|
||||
{};
|
||||
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 0>, proto::basic_expr<Tag, Args2, 0> >
|
||||
: terminal_matches<typename Args1::child0, typename Args2::child0>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2, long N2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 0>, proto::basic_expr<proto::_, Args2, N2> >
|
||||
: mpl::false_
|
||||
{};
|
||||
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 0>, proto::basic_expr<proto::_, Args2, 0> >
|
||||
: terminal_matches<typename Args1::child0, typename Args2::child0>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 1>, proto::basic_expr<Tag, Args2, 1> >
|
||||
: matches_<
|
||||
typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar
|
||||
, typename Args2::child0::proto_grammar
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename Tag, typename Args1, typename Args2>
|
||||
struct matches_< Expr, proto::basic_expr<Tag, Args1, 1>, proto::basic_expr<proto::_, Args2, 1> >
|
||||
: matches_<
|
||||
typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr
|
||||
, typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar
|
||||
, typename Args2::child0::proto_grammar
|
||||
>
|
||||
{};
|
||||
|
||||
#include <boost/proto/detail/and_n.hpp>
|
||||
#include <boost/proto/detail/or_n.hpp>
|
||||
#include <boost/proto/detail/matches_.hpp>
|
||||
#include <boost/proto/detail/vararg_matches_impl.hpp>
|
||||
#include <boost/proto/detail/lambda_matches.hpp>
|
||||
|
||||
// handle proto::if_
|
||||
template<typename Expr, typename Tag, typename Args, long Arity, typename If, typename Then, typename Else>
|
||||
struct matches_<Expr, proto::basic_expr<Tag, Args, Arity>, proto::if_<If, Then, Else> >
|
||||
: mpl::eval_if_c<
|
||||
remove_reference<
|
||||
typename when<_, If>::template impl<Expr, int, int>::result_type
|
||||
>::type::value
|
||||
, matches_<Expr, proto::basic_expr<Tag, Args, Arity>, typename Then::proto_grammar>
|
||||
, matches_<Expr, proto::basic_expr<Tag, Args, Arity>, typename Else::proto_grammar>
|
||||
>::type
|
||||
{
|
||||
typedef
|
||||
typename mpl::if_c<
|
||||
remove_reference<
|
||||
typename when<_, If>::template impl<Expr, int, int>::result_type
|
||||
>::type::value
|
||||
, Then
|
||||
, Else
|
||||
>::type
|
||||
which;
|
||||
};
|
||||
|
||||
// handle degenerate cases of proto::or_
|
||||
template<typename Expr, typename BasicExpr>
|
||||
struct matches_<Expr, BasicExpr, or_<> >
|
||||
: mpl::false_
|
||||
{
|
||||
typedef not_<_> which;
|
||||
};
|
||||
|
||||
template<typename Expr, typename BasicExpr, typename G0>
|
||||
struct matches_<Expr, BasicExpr, or_<G0> >
|
||||
: matches_<Expr, BasicExpr, typename G0::proto_grammar>
|
||||
{
|
||||
typedef G0 which;
|
||||
};
|
||||
|
||||
// handle degenerate cases of proto::and_
|
||||
template<typename Expr, typename BasicExpr>
|
||||
struct matches_<Expr, BasicExpr, and_<> >
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
template<typename Expr, typename BasicExpr, typename G0>
|
||||
struct matches_<Expr, BasicExpr, and_<G0> >
|
||||
: matches_<Expr, BasicExpr, typename G0::proto_grammar>
|
||||
{};
|
||||
|
||||
// handle proto::not_
|
||||
template<typename Expr, typename BasicExpr, typename Grammar>
|
||||
struct matches_<Expr, BasicExpr, not_<Grammar> >
|
||||
: mpl::not_<matches_<Expr, BasicExpr, typename Grammar::proto_grammar> >
|
||||
{};
|
||||
|
||||
// handle proto::switch_
|
||||
template<typename Expr, typename Tag, typename Args, long Arity, typename Cases, typename Transform>
|
||||
struct matches_<Expr, proto::basic_expr<Tag, Args, Arity>, switch_<Cases, Transform> >
|
||||
: matches_<
|
||||
Expr
|
||||
, proto::basic_expr<Tag, Args, Arity>
|
||||
, typename Cases::template case_<
|
||||
typename when<_,Transform>::template impl<Expr,int,int>::result_type
|
||||
>::proto_grammar
|
||||
>
|
||||
{
|
||||
typedef
|
||||
typename Cases::template case_<
|
||||
typename when<_, Transform>::template impl<Expr, int, int>::result_type
|
||||
>
|
||||
which;
|
||||
};
|
||||
|
||||
// handle proto::switch_ with the default Transform for specially for better compile times
|
||||
template<typename Expr, typename Tag, typename Args, long Arity, typename Cases>
|
||||
struct matches_<Expr, proto::basic_expr<Tag, Args, Arity>, switch_<Cases> >
|
||||
: matches_<
|
||||
Expr
|
||||
, proto::basic_expr<Tag, Args, Arity>
|
||||
, typename Cases::template case_<Tag>::proto_grammar
|
||||
>
|
||||
{
|
||||
typedef typename Cases::template case_<Tag> which;
|
||||
};
|
||||
}
|
||||
|
||||
/// \brief A Boolean metafunction that evaluates whether a given
|
||||
/// expression type matches a grammar.
|
||||
///
|
||||
/// <tt>matches\<Expr,Grammar\></tt> inherits (indirectly) from
|
||||
/// \c mpl::true_ if <tt>Expr::proto_grammar</tt> matches
|
||||
/// <tt>Grammar::proto_grammar</tt>, and from \c mpl::false_
|
||||
/// otherwise.
|
||||
///
|
||||
/// Non-terminal expressions are matched against a grammar
|
||||
/// according to the following rules:
|
||||
///
|
||||
/// \li The wildcard pattern, \c _, matches any expression.
|
||||
/// \li An expression <tt>expr\<AT, listN\<A0,A1,...An\> \></tt>
|
||||
/// matches a grammar <tt>expr\<BT, listN\<B0,B1,...Bn\> \></tt>
|
||||
/// if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx for
|
||||
/// each \c x in <tt>[0,n)</tt>.
|
||||
/// \li An expression <tt>expr\<AT, listN\<A0,...An,U0,...Um\> \></tt>
|
||||
/// matches a grammar <tt>expr\<BT, listM\<B0,...Bn,vararg\<V\> \> \></tt>
|
||||
/// if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx
|
||||
/// for each \c x in <tt>[0,n)</tt> and if \c Ux matches \c V
|
||||
/// for each \c x in <tt>[0,m)</tt>.
|
||||
/// \li An expression \c E matches <tt>or_\<B0,B1,...Bn\></tt> if \c E
|
||||
/// matches some \c Bx for \c x in <tt>[0,n)</tt>.
|
||||
/// \li An expression \c E matches <tt>and_\<B0,B1,...Bn\></tt> if \c E
|
||||
/// matches all \c Bx for \c x in <tt>[0,n)</tt>.
|
||||
/// \li An expression \c E matches <tt>if_\<T,U,V\></tt> if
|
||||
/// <tt>boost::result_of\<when\<_,T\>(E,int,int)\>::type::value</tt>
|
||||
/// is \c true and \c E matches \c U; or, if
|
||||
/// <tt>boost::result_of\<when\<_,T\>(E,int,int)\>::type::value</tt>
|
||||
/// is \c false and \c E matches \c V. (Note: \c U defaults to \c _
|
||||
/// and \c V defaults to \c not_\<_\>.)
|
||||
/// \li An expression \c E matches <tt>not_\<T\></tt> if \c E does
|
||||
/// not match \c T.
|
||||
/// \li An expression \c E matches <tt>switch_\<C,T\></tt> if
|
||||
/// \c E matches <tt>C::case_\<boost::result_of\<T(E)\>::type\></tt>.
|
||||
/// (Note: T defaults to <tt>tag_of\<_\>()</tt>.)
|
||||
///
|
||||
/// A terminal expression <tt>expr\<AT,term\<A\> \></tt> matches
|
||||
/// a grammar <tt>expr\<BT,term\<B\> \></tt> if \c BT is \c AT or
|
||||
/// \c proto::_ and if one of the following is true:
|
||||
///
|
||||
/// \li \c B is the wildcard pattern, \c _
|
||||
/// \li \c A is \c B
|
||||
/// \li \c A is <tt>B &</tt>
|
||||
/// \li \c A is <tt>B const &</tt>
|
||||
/// \li \c B is <tt>exact\<A\></tt>
|
||||
/// \li \c B is <tt>convertible_to\<X\></tt> and
|
||||
/// <tt>is_convertible\<A,X\>::value</tt> is \c true.
|
||||
/// \li \c A is <tt>X[M]</tt> or <tt>X(&)[M]</tt> and
|
||||
/// \c B is <tt>X[proto::N]</tt>.
|
||||
/// \li \c A is <tt>X(&)[M]</tt> and \c B is <tt>X(&)[proto::N]</tt>.
|
||||
/// \li \c A is <tt>X[M]</tt> or <tt>X(&)[M]</tt> and
|
||||
/// \c B is <tt>X*</tt>.
|
||||
/// \li \c B lambda-matches \c A (see below).
|
||||
///
|
||||
/// A type \c B lambda-matches \c A if one of the following is true:
|
||||
///
|
||||
/// \li \c B is \c A
|
||||
/// \li \c B is the wildcard pattern, \c _
|
||||
/// \li \c B is <tt>T\<B0,B1,...Bn\></tt> and \c A is
|
||||
/// <tt>T\<A0,A1,...An\></tt> and for each \c x in
|
||||
/// <tt>[0,n)</tt>, \c Ax and \c Bx are types
|
||||
/// such that \c Ax lambda-matches \c Bx
|
||||
template<typename Expr, typename Grammar>
|
||||
struct matches
|
||||
: detail::matches_<
|
||||
typename Expr::proto_derived_expr
|
||||
, typename Expr::proto_grammar
|
||||
, typename Grammar::proto_grammar
|
||||
>
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename Expr, typename Grammar>
|
||||
struct matches<Expr &, Grammar>
|
||||
: detail::matches_<
|
||||
typename Expr::proto_derived_expr
|
||||
, typename Expr::proto_grammar
|
||||
, typename Grammar::proto_grammar
|
||||
>
|
||||
{};
|
||||
|
||||
/// \brief A wildcard grammar element that matches any expression,
|
||||
/// and a transform that returns the current expression unchanged.
|
||||
///
|
||||
/// The wildcard type, \c _, is a grammar element such that
|
||||
/// <tt>matches\<E,_\>::value</tt> is \c true for any expression
|
||||
/// type \c E.
|
||||
///
|
||||
/// The wildcard can also be used as a stand-in for a template
|
||||
/// argument when matching terminals. For instance, the following
|
||||
/// is a grammar that will match any <tt>std::complex\<\></tt>
|
||||
/// terminal:
|
||||
///
|
||||
/// \code
|
||||
/// BOOST_MPL_ASSERT((
|
||||
/// matches<
|
||||
/// terminal<std::complex<double> >::type
|
||||
/// , terminal<std::complex< _ > >
|
||||
/// >
|
||||
/// ));
|
||||
/// \endcode
|
||||
///
|
||||
/// When used as a transform, \c _ returns the current expression
|
||||
/// unchanged. For instance, in the following, \c _ is used with
|
||||
/// the \c fold\<\> transform to fold the children of a node:
|
||||
///
|
||||
/// \code
|
||||
/// struct CountChildren
|
||||
/// : or_<
|
||||
/// // Terminals have no children
|
||||
/// when<terminal<_>, mpl::int_<0>()>
|
||||
/// // Use fold<> to count the children of non-terminals
|
||||
/// , otherwise<
|
||||
/// fold<
|
||||
/// _ // <-- fold the current expression
|
||||
/// , mpl::int_<0>()
|
||||
/// , mpl::plus<_state, mpl::int_<1> >()
|
||||
/// >
|
||||
/// >
|
||||
/// >
|
||||
/// {};
|
||||
/// \endcode
|
||||
struct _ : transform<_>
|
||||
{
|
||||
typedef _ proto_grammar;
|
||||
|
||||
template<typename Expr, typename State, typename Data>
|
||||
struct impl : transform_impl<Expr, State, Data>
|
||||
{
|
||||
typedef Expr result_type;
|
||||
|
||||
/// \param expr An expression
|
||||
/// \return \c e
|
||||
#ifdef BOOST_PROTO_STRICT_RESULT_OF
|
||||
result_type
|
||||
#else
|
||||
typename impl::expr_param
|
||||
#endif
|
||||
operator()(
|
||||
typename impl::expr_param e
|
||||
, typename impl::state_param
|
||||
, typename impl::data_param
|
||||
) const
|
||||
{
|
||||
return e;
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template<typename Expr, typename State, typename Data>
|
||||
struct _and_impl<proto::and_<>, Expr, State, Data>
|
||||
: proto::_::impl<Expr, State, Data>
|
||||
{};
|
||||
|
||||
template<typename G0, typename Expr, typename State, typename Data>
|
||||
struct _and_impl<proto::and_<G0>, Expr, State, Data>
|
||||
: proto::when<proto::_, G0>::template impl<Expr, State, Data>
|
||||
{};
|
||||
}
|
||||
|
||||
/// \brief Inverts the set of expressions matched by a grammar. When
|
||||
/// used as a transform, \c not_\<\> returns the current expression
|
||||
/// unchanged.
|
||||
///
|
||||
/// If an expression type \c E does not match a grammar \c G, then
|
||||
/// \c E \e does match <tt>not_\<G\></tt>. For example,
|
||||
/// <tt>not_\<terminal\<_\> \></tt> will match any non-terminal.
|
||||
template<typename Grammar>
|
||||
struct not_ : transform<not_<Grammar> >
|
||||
{
|
||||
typedef not_ proto_grammar;
|
||||
|
||||
template<typename Expr, typename State, typename Data>
|
||||
struct impl : transform_impl<Expr, State, Data>
|
||||
{
|
||||
typedef Expr result_type;
|
||||
|
||||
/// \param e An expression
|
||||
/// \pre <tt>matches\<Expr,not_\>::value</tt> is \c true.
|
||||
/// \return \c e
|
||||
#ifdef BOOST_PROTO_STRICT_RESULT_OF
|
||||
result_type
|
||||
#else
|
||||
typename impl::expr_param
|
||||
#endif
|
||||
operator()(
|
||||
typename impl::expr_param e
|
||||
, typename impl::state_param
|
||||
, typename impl::data_param
|
||||
) const
|
||||
{
|
||||
return e;
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
/// \brief Used to select one grammar or another based on the result
|
||||
/// of a compile-time Boolean. When used as a transform, \c if_\<\>
|
||||
/// selects between two transforms based on a compile-time Boolean.
|
||||
///
|
||||
/// When <tt>if_\<If,Then,Else\></tt> is used as a grammar, \c If
|
||||
/// must be a Proto transform and \c Then and \c Else must be grammars.
|
||||
/// An expression type \c E matches <tt>if_\<If,Then,Else\></tt> if
|
||||
/// <tt>boost::result_of\<when\<_,If\>(E,int,int)\>::type::value</tt>
|
||||
/// is \c true and \c E matches \c U; or, if
|
||||
/// <tt>boost::result_of\<when\<_,If\>(E,int,int)\>::type::value</tt>
|
||||
/// is \c false and \c E matches \c V.
|
||||
///
|
||||
/// The template parameter \c Then defaults to \c _
|
||||
/// and \c Else defaults to \c not\<_\>, so an expression type \c E
|
||||
/// will match <tt>if_\<If\></tt> if and only if
|
||||
/// <tt>boost::result_of\<when\<_,If\>(E,int,int)\>::type::value</tt>
|
||||
/// is \c true.
|
||||
///
|
||||
/// \code
|
||||
/// // A grammar that only matches integral terminals,
|
||||
/// // using is_integral<> from Boost.Type_traits.
|
||||
/// struct IsIntegral
|
||||
/// : and_<
|
||||
/// terminal<_>
|
||||
/// , if_< is_integral<_value>() >
|
||||
/// >
|
||||
/// {};
|
||||
/// \endcode
|
||||
///
|
||||
/// When <tt>if_\<If,Then,Else\></tt> is used as a transform, \c If,
|
||||
/// \c Then and \c Else must be Proto transforms. When applying
|
||||
/// the transform to an expression \c E, state \c S and data \c V,
|
||||
/// if <tt>boost::result_of\<when\<_,If\>(E,S,V)\>::type::value</tt>
|
||||
/// is \c true then the \c Then transform is applied; otherwise
|
||||
/// the \c Else transform is applied.
|
||||
///
|
||||
/// \code
|
||||
/// // Match a terminal. If the terminal is integral, return
|
||||
/// // mpl::true_; otherwise, return mpl::false_.
|
||||
/// struct IsIntegral2
|
||||
/// : when<
|
||||
/// terminal<_>
|
||||
/// , if_<
|
||||
/// is_integral<_value>()
|
||||
/// , mpl::true_()
|
||||
/// , mpl::false_()
|
||||
/// >
|
||||
/// >
|
||||
/// {};
|
||||
/// \endcode
|
||||
template<
|
||||
typename If
|
||||
, typename Then // = _
|
||||
, typename Else // = not_<_>
|
||||
>
|
||||
struct if_ : transform<if_<If, Then, Else> >
|
||||
{
|
||||
typedef if_ proto_grammar;
|
||||
|
||||
template<typename Expr, typename State, typename Data>
|
||||
struct impl : transform_impl<Expr, State, Data>
|
||||
{
|
||||
typedef
|
||||
typename when<_, If>::template impl<Expr, State, Data>::result_type
|
||||
condition;
|
||||
|
||||
typedef
|
||||
typename mpl::if_c<
|
||||
remove_reference<condition>::type::value
|
||||
, when<_, Then>
|
||||
, when<_, Else>
|
||||
>::type
|
||||
which;
|
||||
|
||||
typedef typename which::template impl<Expr, State, Data>::result_type result_type;
|
||||
|
||||
/// \param e An expression
|
||||
/// \param s The current state
|
||||
/// \param d A data of arbitrary type
|
||||
/// \return <tt>which::impl<Expr, State, Data>()(e, s, d)</tt>
|
||||
result_type operator ()(
|
||||
typename impl::expr_param e
|
||||
, typename impl::state_param s
|
||||
, typename impl::data_param d
|
||||
) const
|
||||
{
|
||||
return typename which::template impl<Expr, State, Data>()(e, s, d);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
/// \brief For matching one of a set of alternate grammars. Alternates
|
||||
/// tried in order to avoid ambiguity. When used as a transform, \c or_\<\>
|
||||
/// applies the transform associated with the first grammar that matches
|
||||
/// the expression.
|
||||
///
|
||||
/// An expression type \c E matches <tt>or_\<B0,B1,...Bn\></tt> if \c E
|
||||
/// matches any \c Bx for \c x in <tt>[0,n)</tt>.
|
||||
///
|
||||
/// When applying <tt>or_\<B0,B1,...Bn\></tt> as a transform with an
|
||||
/// expression \c e of type \c E, state \c s and data \c d, it is
|
||||
/// equivalent to <tt>Bx()(e, s, d)</tt>, where \c x is the lowest
|
||||
/// number such that <tt>matches\<E,Bx\>::value</tt> is \c true.
|
||||
template<BOOST_PROTO_LOGICAL_typename_G>
|
||||
struct or_ : transform<or_<BOOST_PROTO_LOGICAL_G> >
|
||||
{
|
||||
typedef or_ proto_grammar;
|
||||
|
||||
/// \param e An expression
|
||||
/// \param s The current state
|
||||
/// \param d A data of arbitrary type
|
||||
/// \pre <tt>matches\<Expr,or_\>::value</tt> is \c true.
|
||||
/// \return <tt>which()(e, s, d)</tt>, where <tt>which</tt> is the
|
||||
/// sub-grammar that matched <tt>Expr</tt>.
|
||||
|
||||
template<typename Expr, typename State, typename Data>
|
||||
struct impl
|
||||
: detail::matches_<
|
||||
typename Expr::proto_derived_expr
|
||||
, typename Expr::proto_grammar
|
||||
, or_
|
||||
>::which::template impl<Expr, State, Data>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename State, typename Data>
|
||||
struct impl<Expr &, State, Data>
|
||||
: detail::matches_<
|
||||
typename Expr::proto_derived_expr
|
||||
, typename Expr::proto_grammar
|
||||
, or_
|
||||
>::which::template impl<Expr &, State, Data>
|
||||
{};
|
||||
};
|
||||
|
||||
/// \brief For matching all of a set of grammars. When used as a
|
||||
/// transform, \c and_\<\> applies the transforms associated with
|
||||
/// the each grammar in the set, and returns the result of the last.
|
||||
///
|
||||
/// An expression type \c E matches <tt>and_\<B0,B1,...Bn\></tt> if \c E
|
||||
/// matches all \c Bx for \c x in <tt>[0,n)</tt>.
|
||||
///
|
||||
/// When applying <tt>and_\<B0,B1,...Bn\></tt> as a transform with an
|
||||
/// expression \c e, state \c s and data \c d, it is
|
||||
/// equivalent to <tt>(B0()(e, s, d),B1()(e, s, d),...Bn()(e, s, d))</tt>.
|
||||
template<BOOST_PROTO_LOGICAL_typename_G>
|
||||
struct and_ : transform<and_<BOOST_PROTO_LOGICAL_G> >
|
||||
{
|
||||
typedef and_ proto_grammar;
|
||||
|
||||
template<typename Expr, typename State, typename Data>
|
||||
struct impl
|
||||
: detail::_and_impl<and_, Expr, State, Data>
|
||||
{};
|
||||
};
|
||||
|
||||
/// \brief For matching one of a set of alternate grammars, which
|
||||
/// are looked up based on some property of an expression. The
|
||||
/// property on which to dispatch is specified by the \c Transform
|
||||
/// template parameter, which defaults to <tt>tag_of\<_\>()</tt>.
|
||||
/// That is, when the \c Trannsform is not specified, the alternate
|
||||
/// grammar is looked up using the tag type of the current expression.
|
||||
///
|
||||
/// When used as a transform, \c switch_\<\> applies the transform
|
||||
/// associated with the grammar that matches the expression.
|
||||
///
|
||||
/// \note \c switch_\<\> is functionally identical to \c or_\<\> but
|
||||
/// is often more efficient. It does a fast, O(1) lookup using the
|
||||
/// result of the specified transform to find a sub-grammar that may
|
||||
/// potentially match the expression.
|
||||
///
|
||||
/// An expression type \c E matches <tt>switch_\<C,T\></tt> if \c E
|
||||
/// matches <tt>C::case_\<boost::result_of\<T(E)\>::type\></tt>.
|
||||
///
|
||||
/// When applying <tt>switch_\<C,T\></tt> as a transform with an
|
||||
/// expression \c e of type \c E, state \c s of type \S and data
|
||||
/// \c d of type \c D, it is equivalent to
|
||||
/// <tt>C::case_\<boost::result_of\<T(E,S,D)\>::type\>()(e, s, d)</tt>.
|
||||
template<typename Cases, typename Transform>
|
||||
struct switch_ : transform<switch_<Cases, Transform> >
|
||||
{
|
||||
typedef switch_ proto_grammar;
|
||||
|
||||
template<typename Expr, typename State, typename Data>
|
||||
struct impl
|
||||
: Cases::template case_<
|
||||
typename when<_, Transform>::template impl<Expr, State, Data>::result_type
|
||||
>::template impl<Expr, State, Data>
|
||||
{};
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY (This is merely a compile-time optimization for the common case)
|
||||
///
|
||||
template<typename Cases>
|
||||
struct switch_<Cases> : transform<switch_<Cases> >
|
||||
{
|
||||
typedef switch_ proto_grammar;
|
||||
|
||||
template<typename Expr, typename State, typename Data>
|
||||
struct impl
|
||||
: Cases::template case_<typename Expr::proto_tag>::template impl<Expr, State, Data>
|
||||
{};
|
||||
|
||||
template<typename Expr, typename State, typename Data>
|
||||
struct impl<Expr &, State, Data>
|
||||
: Cases::template case_<typename Expr::proto_tag>::template impl<Expr &, State, Data>
|
||||
{};
|
||||
};
|
||||
|
||||
/// \brief For forcing exact matches of terminal types.
|
||||
///
|
||||
/// By default, matching terminals ignores references and
|
||||
/// cv-qualifiers. For instance, a terminal expression of
|
||||
/// type <tt>terminal\<int const &\>::type</tt> will match
|
||||
/// the grammar <tt>terminal\<int\></tt>. If that is not
|
||||
/// desired, you can force an exact match with
|
||||
/// <tt>terminal\<exact\<int\> \></tt>. This will only
|
||||
/// match integer terminals where the terminal is held by
|
||||
/// value.
|
||||
template<typename T>
|
||||
struct exact
|
||||
{};
|
||||
|
||||
/// \brief For matching terminals that are convertible to
|
||||
/// a type.
|
||||
///
|
||||
/// Use \c convertible_to\<\> to match a terminal that is
|
||||
/// convertible to some type. For example, the grammar
|
||||
/// <tt>terminal\<convertible_to\<int\> \></tt> will match
|
||||
/// any terminal whose argument is convertible to an integer.
|
||||
///
|
||||
/// \note The trait \c is_convertible\<\> from Boost.Type_traits
|
||||
/// is used to determinal convertibility.
|
||||
template<typename T>
|
||||
struct convertible_to
|
||||
{};
|
||||
|
||||
/// \brief For matching a Grammar to a variable number of
|
||||
/// sub-expressions.
|
||||
///
|
||||
/// An expression type <tt>expr\<AT, listN\<A0,...An,U0,...Um\> \></tt>
|
||||
/// matches a grammar <tt>expr\<BT, listM\<B0,...Bn,vararg\<V\> \> \></tt>
|
||||
/// if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx
|
||||
/// for each \c x in <tt>[0,n)</tt> and if \c Ux matches \c V
|
||||
/// for each \c x in <tt>[0,m)</tt>.
|
||||
///
|
||||
/// For example:
|
||||
///
|
||||
/// \code
|
||||
/// // Match any function call expression, irregardless
|
||||
/// // of the number of function arguments:
|
||||
/// struct Function
|
||||
/// : function< vararg<_> >
|
||||
/// {};
|
||||
/// \endcode
|
||||
///
|
||||
/// When used as a transform, <tt>vararg\<G\></tt> applies
|
||||
/// <tt>G</tt>'s transform.
|
||||
template<typename Grammar>
|
||||
struct vararg
|
||||
: Grammar
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
typedef void proto_is_vararg_;
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<BOOST_PROTO_LOGICAL_typename_G>
|
||||
struct is_callable<or_<BOOST_PROTO_LOGICAL_G> >
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<BOOST_PROTO_LOGICAL_typename_G>
|
||||
struct is_callable<and_<BOOST_PROTO_LOGICAL_G> >
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename Grammar>
|
||||
struct is_callable<not_<Grammar> >
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename If, typename Then, typename Else>
|
||||
struct is_callable<if_<If, Then, Else> >
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename Grammar>
|
||||
struct is_callable<vararg<Grammar> >
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename Cases, typename Transform>
|
||||
struct is_callable<switch_<Cases, Transform> >
|
||||
: mpl::true_
|
||||
{};
|
||||
|
||||
}}
|
||||
|
||||
#undef BOOST_PROTO_LOGICAL_typename_G
|
||||
#undef BOOST_PROTO_LOGICAL_G
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
360
test/external/boost/proto/operators.hpp
vendored
Normal file
360
test/external/boost/proto/operators.hpp
vendored
Normal file
@@ -0,0 +1,360 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file operators.hpp
|
||||
/// Contains all the overloaded operators that make it possible to build
|
||||
/// Proto expression trees.
|
||||
//
|
||||
// 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_OPERATORS_HPP_EAN_04_01_2005
|
||||
#define BOOST_PROTO_OPERATORS_HPP_EAN_04_01_2005
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/preprocessor/punctuation/comma.hpp>
|
||||
#include <boost/mpl/logical.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/tags.hpp>
|
||||
#include <boost/proto/domain.hpp>
|
||||
#include <boost/proto/matches.hpp>
|
||||
#include <boost/proto/generate.hpp>
|
||||
#include <boost/proto/make_expr.hpp>
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
template<typename MakeExpr, typename Grammar>
|
||||
struct lazy_matches
|
||||
: proto::matches<typename MakeExpr::type, Grammar>
|
||||
{};
|
||||
|
||||
template<typename Domain, typename Grammar, typename Trait, typename Tag, typename Arg>
|
||||
struct enable_unary
|
||||
: boost::lazy_enable_if_c<
|
||||
boost::mpl::and_<
|
||||
Trait
|
||||
, lazy_matches<result_of::make_expr<Tag, basic_default_domain, Arg>, Grammar>
|
||||
>::value
|
||||
, result_of::make_expr<Tag, Domain, Arg>
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Domain, typename Trait, typename Tag, typename Arg>
|
||||
struct enable_unary<Domain, proto::_, Trait, Tag, Arg &>
|
||||
: boost::lazy_enable_if_c<
|
||||
Trait::value
|
||||
, result_of::make_expr<Tag, Domain, Arg &>
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Trait, typename Tag, typename Arg>
|
||||
struct enable_unary<deduce_domain, not_a_grammar, Trait, Tag, Arg &>
|
||||
: enable_unary<
|
||||
typename domain_of<Arg>::type
|
||||
, typename domain_of<Arg>::type::proto_grammar
|
||||
, Trait
|
||||
, Tag
|
||||
, Arg &
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Domain, typename Grammar, typename Trait, typename Tag, typename Left, typename Right>
|
||||
struct enable_binary
|
||||
: boost::lazy_enable_if_c<
|
||||
boost::mpl::and_<
|
||||
Trait
|
||||
, lazy_matches<result_of::make_expr<Tag, basic_default_domain, Left, Right>, Grammar>
|
||||
>::value
|
||||
, result_of::make_expr<Tag, Domain, Left, Right>
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Domain, typename Trait, typename Tag, typename Left, typename Right>
|
||||
struct enable_binary<Domain, proto::_, Trait, Tag, Left &, Right &>
|
||||
: boost::lazy_enable_if_c<
|
||||
Trait::value
|
||||
, result_of::make_expr<Tag, Domain, Left &, Right &>
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Trait, typename Tag, typename Left, typename Right>
|
||||
struct enable_binary<deduce_domain, not_a_grammar, Trait, Tag, Left &, Right &>
|
||||
: enable_binary<
|
||||
typename deduce_domain2<Left, Right>::type
|
||||
, typename deduce_domain2<Left, Right>::type::proto_grammar
|
||||
, Trait
|
||||
, Tag
|
||||
, Left &
|
||||
, Right &
|
||||
>
|
||||
{};
|
||||
|
||||
} // detail
|
||||
|
||||
#define BOOST_PROTO_UNARY_OP_IS_POSTFIX_0
|
||||
#define BOOST_PROTO_UNARY_OP_IS_POSTFIX_1 , int
|
||||
|
||||
#ifdef BOOST_NO_RVALUE_REFERENCES
|
||||
|
||||
#define BOOST_PROTO_DEFINE_UNARY_OPERATOR(OP, TAG, TRAIT, DOMAIN, POST) \
|
||||
template<typename Arg> \
|
||||
typename boost::proto::detail::enable_unary< \
|
||||
DOMAIN \
|
||||
, DOMAIN::proto_grammar \
|
||||
, BOOST_PROTO_APPLY_UNARY_(TRAIT, Arg) \
|
||||
, TAG \
|
||||
, Arg & \
|
||||
>::type const \
|
||||
operator OP(Arg &arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST) \
|
||||
{ \
|
||||
return boost::proto::detail::make_expr_<TAG, DOMAIN, Arg &>()(arg); \
|
||||
} \
|
||||
\
|
||||
template<typename Arg> \
|
||||
typename boost::proto::detail::enable_unary< \
|
||||
DOMAIN \
|
||||
, DOMAIN::proto_grammar \
|
||||
, BOOST_PROTO_APPLY_UNARY_(TRAIT, Arg) \
|
||||
, TAG \
|
||||
, Arg const & \
|
||||
>::type const \
|
||||
operator OP(Arg const &arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST) \
|
||||
{ \
|
||||
return boost::proto::detail::make_expr_<TAG, DOMAIN, Arg const &>()(arg); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_DEFINE_BINARY_OPERATOR(OP, TAG, TRAIT, DOMAIN) \
|
||||
template<typename Left, typename Right> \
|
||||
typename boost::proto::detail::enable_binary< \
|
||||
DOMAIN \
|
||||
, DOMAIN::proto_grammar \
|
||||
, BOOST_PROTO_APPLY_BINARY_(TRAIT, Left, Right) \
|
||||
, TAG \
|
||||
, Left & \
|
||||
, Right & \
|
||||
>::type const \
|
||||
operator OP(Left &left, Right &right) \
|
||||
{ \
|
||||
return boost::proto::detail::make_expr_<TAG, DOMAIN, Left &, Right &>()(left, right); \
|
||||
} \
|
||||
\
|
||||
template<typename Left, typename Right> \
|
||||
typename boost::proto::detail::enable_binary< \
|
||||
DOMAIN \
|
||||
, DOMAIN::proto_grammar \
|
||||
, BOOST_PROTO_APPLY_BINARY_(TRAIT, Left, Right) \
|
||||
, TAG \
|
||||
, Left & \
|
||||
, Right const & \
|
||||
>::type const \
|
||||
operator OP(Left &left, Right const &right) \
|
||||
{ \
|
||||
return boost::proto::detail::make_expr_<TAG, DOMAIN, Left &, Right const &>()(left, right); \
|
||||
} \
|
||||
\
|
||||
template<typename Left, typename Right> \
|
||||
typename boost::proto::detail::enable_binary< \
|
||||
DOMAIN \
|
||||
, DOMAIN::proto_grammar \
|
||||
, BOOST_PROTO_APPLY_BINARY_(TRAIT, Left, Right) \
|
||||
, TAG \
|
||||
, Left const & \
|
||||
, Right & \
|
||||
>::type const \
|
||||
operator OP(Left const &left, Right &right) \
|
||||
{ \
|
||||
return boost::proto::detail::make_expr_<TAG, DOMAIN, Left const &, Right &>()(left, right); \
|
||||
} \
|
||||
\
|
||||
template<typename Left, typename Right> \
|
||||
typename boost::proto::detail::enable_binary< \
|
||||
DOMAIN \
|
||||
, DOMAIN::proto_grammar \
|
||||
, BOOST_PROTO_APPLY_BINARY_(TRAIT, Left, Right) \
|
||||
, TAG \
|
||||
, Left const & \
|
||||
, Right const & \
|
||||
>::type const \
|
||||
operator OP(Left const &left, Right const &right) \
|
||||
{ \
|
||||
return boost::proto::detail::make_expr_<TAG, DOMAIN, Left const &, Right const &>()(left, right);\
|
||||
} \
|
||||
/**/
|
||||
|
||||
#else
|
||||
|
||||
#define BOOST_PROTO_DEFINE_UNARY_OPERATOR(OP, TAG, TRAIT, DOMAIN, POST) \
|
||||
template<typename Arg> \
|
||||
typename boost::proto::detail::enable_unary< \
|
||||
DOMAIN \
|
||||
, DOMAIN::proto_grammar \
|
||||
, BOOST_PROTO_APPLY_UNARY_(TRAIT, Arg) \
|
||||
, TAG \
|
||||
, Arg const & \
|
||||
>::type const \
|
||||
operator OP(Arg &&arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST) \
|
||||
{ \
|
||||
return boost::proto::detail::make_expr_<TAG, DOMAIN, Arg const &>()(arg); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_DEFINE_BINARY_OPERATOR(OP, TAG, TRAIT, DOMAIN) \
|
||||
template<typename Left, typename Right> \
|
||||
typename boost::proto::detail::enable_binary< \
|
||||
DOMAIN \
|
||||
, DOMAIN::proto_grammar \
|
||||
, BOOST_PROTO_APPLY_BINARY_(TRAIT, Left, Right) \
|
||||
, TAG \
|
||||
, Left const & \
|
||||
, Right const & \
|
||||
>::type const \
|
||||
operator OP(Left &&left, Right &&right) \
|
||||
{ \
|
||||
return boost::proto::detail::make_expr_<TAG, DOMAIN, Left const &, Right const &>()(left, right);\
|
||||
} \
|
||||
/**/
|
||||
|
||||
#endif
|
||||
|
||||
#define BOOST_PROTO_DEFINE_OPERATORS(TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_UNARY_OPERATOR(+, boost::proto::tag::unary_plus, TRAIT, DOMAIN, 0) \
|
||||
BOOST_PROTO_DEFINE_UNARY_OPERATOR(-, boost::proto::tag::negate, TRAIT, DOMAIN, 0) \
|
||||
BOOST_PROTO_DEFINE_UNARY_OPERATOR(*, boost::proto::tag::dereference, TRAIT, DOMAIN, 0) \
|
||||
BOOST_PROTO_DEFINE_UNARY_OPERATOR(~, boost::proto::tag::complement, TRAIT, DOMAIN, 0) \
|
||||
BOOST_PROTO_DEFINE_UNARY_OPERATOR(&, boost::proto::tag::address_of, TRAIT, DOMAIN, 0) \
|
||||
BOOST_PROTO_DEFINE_UNARY_OPERATOR(!, boost::proto::tag::logical_not, TRAIT, DOMAIN, 0) \
|
||||
BOOST_PROTO_DEFINE_UNARY_OPERATOR(++, boost::proto::tag::pre_inc, TRAIT, DOMAIN, 0) \
|
||||
BOOST_PROTO_DEFINE_UNARY_OPERATOR(--, boost::proto::tag::pre_dec, TRAIT, DOMAIN, 0) \
|
||||
BOOST_PROTO_DEFINE_UNARY_OPERATOR(++, boost::proto::tag::post_inc, TRAIT, DOMAIN, 1) \
|
||||
BOOST_PROTO_DEFINE_UNARY_OPERATOR(--, boost::proto::tag::post_dec, TRAIT, DOMAIN, 1) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(<<, boost::proto::tag::shift_left, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(>>, boost::proto::tag::shift_right, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(*, boost::proto::tag::multiplies, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(/, boost::proto::tag::divides, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(%, boost::proto::tag::modulus, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(+, boost::proto::tag::plus, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(-, boost::proto::tag::minus, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(<, boost::proto::tag::less, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(>, boost::proto::tag::greater, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(<=, boost::proto::tag::less_equal, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(>=, boost::proto::tag::greater_equal, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(==, boost::proto::tag::equal_to, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(!=, boost::proto::tag::not_equal_to, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(||, boost::proto::tag::logical_or, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(&&, boost::proto::tag::logical_and, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(&, boost::proto::tag::bitwise_and, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(|, boost::proto::tag::bitwise_or, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(^, boost::proto::tag::bitwise_xor, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(BOOST_PP_COMMA(), boost::proto::tag::comma, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(->*, boost::proto::tag::mem_ptr, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(<<=, boost::proto::tag::shift_left_assign, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(>>=, boost::proto::tag::shift_right_assign, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(*=, boost::proto::tag::multiplies_assign, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(/=, boost::proto::tag::divides_assign, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(%=, boost::proto::tag::modulus_assign, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(+=, boost::proto::tag::plus_assign, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(-=, boost::proto::tag::minus_assign, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(&=, boost::proto::tag::bitwise_and_assign, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(|=, boost::proto::tag::bitwise_or_assign, TRAIT, DOMAIN) \
|
||||
BOOST_PROTO_DEFINE_BINARY_OPERATOR(^=, boost::proto::tag::bitwise_xor_assign, TRAIT, DOMAIN) \
|
||||
/**/
|
||||
|
||||
// Extensions are a superset of Proto expressions
|
||||
template<typename T>
|
||||
struct is_extension
|
||||
: is_expr<T>
|
||||
{};
|
||||
|
||||
template<typename T>
|
||||
struct is_extension<T &>
|
||||
: is_expr<T>
|
||||
{};
|
||||
|
||||
#define BOOST_PROTO_APPLY_UNARY_(TRAIT, ARG) TRAIT<ARG>
|
||||
#define BOOST_PROTO_APPLY_BINARY_(TRAIT, LEFT, RIGHT) boost::mpl::or_<TRAIT<LEFT>, TRAIT<RIGHT> >
|
||||
|
||||
namespace exprns_
|
||||
{
|
||||
// This defines all of Proto's built-in free operator overloads
|
||||
BOOST_PROTO_DEFINE_OPERATORS(is_extension, deduce_domain)
|
||||
|
||||
// if_else, for the non-overloadable ternary conditional operator ?:
|
||||
template<typename A0, typename A1, typename A2>
|
||||
typename result_of::make_expr<
|
||||
tag::if_else_
|
||||
, deduce_domain
|
||||
, A0 const &
|
||||
, A1 const &
|
||||
, A2 const &
|
||||
>::type const
|
||||
if_else(A0 const &a0, A1 const &a1, A2 const &a2)
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
tag::if_else_
|
||||
, deduce_domain
|
||||
, A0 const &
|
||||
, A1 const &
|
||||
, A2 const &
|
||||
>()(a0, a1, a2);
|
||||
}
|
||||
}
|
||||
|
||||
using exprns_::if_else;
|
||||
|
||||
#undef BOOST_PROTO_APPLY_UNARY_
|
||||
#undef BOOST_PROTO_APPLY_BINARY_
|
||||
|
||||
// Redefine BOOST_PROTO_APPLY_UNARY_ and BOOST_PROTO_APPLY_BINARY_ so that end users
|
||||
// can use BOOST_PROTO_DEFINE_OPERATORS to define Proto operator overloads that work
|
||||
// with their own terminal types.
|
||||
|
||||
#ifdef BOOST_NO_RVALUE_REFERENCES
|
||||
|
||||
#define BOOST_PROTO_APPLY_UNARY_(TRAIT, ARG) \
|
||||
boost::mpl::and_< \
|
||||
TRAIT<ARG> \
|
||||
, boost::mpl::not_<boost::proto::is_extension<ARG> > \
|
||||
> \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_APPLY_BINARY_(TRAIT, LEFT, RIGHT) \
|
||||
boost::mpl::and_< \
|
||||
boost::mpl::or_<TRAIT<LEFT>, TRAIT<RIGHT> > \
|
||||
, boost::mpl::not_< \
|
||||
boost::mpl::or_< \
|
||||
boost::proto::is_extension<LEFT> \
|
||||
, boost::proto::is_extension<RIGHT> \
|
||||
> \
|
||||
> \
|
||||
> \
|
||||
/**/
|
||||
|
||||
#else
|
||||
|
||||
#define BOOST_PROTO_APPLY_UNARY_(TRAIT, ARG) \
|
||||
boost::mpl::and_< \
|
||||
TRAIT<BOOST_PROTO_UNCVREF(ARG) > \
|
||||
, boost::mpl::not_<boost::proto::is_extension<ARG> > \
|
||||
> \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_APPLY_BINARY_(TRAIT, LEFT, RIGHT) \
|
||||
boost::mpl::and_< \
|
||||
boost::mpl::or_<TRAIT<BOOST_PROTO_UNCVREF(LEFT) >, TRAIT<BOOST_PROTO_UNCVREF(RIGHT) > > \
|
||||
, boost::mpl::not_< \
|
||||
boost::mpl::or_< \
|
||||
boost::proto::is_extension<LEFT> \
|
||||
, boost::proto::is_extension<RIGHT> \
|
||||
> \
|
||||
> \
|
||||
> \
|
||||
/**/
|
||||
|
||||
#endif
|
||||
|
||||
}}
|
||||
|
||||
#endif
|
||||
18
test/external/boost/proto/proto.hpp
vendored
Normal file
18
test/external/boost/proto/proto.hpp
vendored
Normal file
@@ -0,0 +1,18 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file proto.hpp
|
||||
/// Includes all of Proto.
|
||||
//
|
||||
// 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_HPP_EAN_04_01_2005
|
||||
#define BOOST_PROTO_HPP_EAN_04_01_2005
|
||||
|
||||
#include <boost/proto/core.hpp>
|
||||
#include <boost/proto/debug.hpp>
|
||||
#include <boost/proto/context.hpp>
|
||||
#include <boost/proto/transform.hpp>
|
||||
#include <boost/proto/functional.hpp>
|
||||
|
||||
#endif
|
||||
808
test/external/boost/proto/proto_fwd.hpp
vendored
Normal file
808
test/external/boost/proto/proto_fwd.hpp
vendored
Normal file
@@ -0,0 +1,808 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file proto_fwd.hpp
|
||||
/// Forward declarations of all of proto's public types and functions.
|
||||
//
|
||||
// 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_FWD_HPP_EAN_04_01_2005
|
||||
#define BOOST_PROTO_FWD_HPP_EAN_04_01_2005
|
||||
|
||||
#include <cstddef>
|
||||
#include <climits>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/arithmetic/inc.hpp>
|
||||
#include <boost/preprocessor/punctuation/comma.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
#include <boost/mpl/long.hpp>
|
||||
#include <boost/type_traits/remove_const.hpp>
|
||||
#include <boost/type_traits/remove_reference.hpp>
|
||||
#include <boost/mpl/aux_/config/ttp.hpp>
|
||||
|
||||
#ifndef BOOST_PROTO_MAX_ARITY
|
||||
# define BOOST_PROTO_MAX_ARITY 10
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_PROTO_MAX_LOGICAL_ARITY
|
||||
# define BOOST_PROTO_MAX_LOGICAL_ARITY 10
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_PROTO_MAX_FUNCTION_CALL_ARITY
|
||||
# define BOOST_PROTO_MAX_FUNCTION_CALL_ARITY BOOST_PROTO_MAX_ARITY
|
||||
#endif
|
||||
|
||||
#if BOOST_PROTO_MAX_ARITY < 3
|
||||
# error BOOST_PROTO_MAX_ARITY must be at least 3
|
||||
#endif
|
||||
|
||||
#if BOOST_PROTO_MAX_FUNCTION_CALL_ARITY > BOOST_PROTO_MAX_ARITY
|
||||
# error BOOST_PROTO_MAX_FUNCTION_CALL_ARITY cannot be larger than BOOST_PROTO_MAX_ARITY
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_PROTO_DONT_USE_PREPROCESSED_FILES
|
||||
#if 10 < BOOST_PROTO_MAX_ARITY || \
|
||||
10 < BOOST_PROTO_MAX_LOGICAL_ARITY || \
|
||||
10 < BOOST_PROTO_MAX_FUNCTION_CALL_ARITY
|
||||
#define BOOST_PROTO_DONT_USE_PREPROCESSED_FILES
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_PROTO_BROKEN_CONST_OVERLOADS
|
||||
# if BOOST_WORKAROUND(__GNUC__, == 3) \
|
||||
|| BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(310))
|
||||
# define BOOST_PROTO_BROKEN_CONST_OVERLOADS
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS
|
||||
# if BOOST_WORKAROUND(__GNUC__, == 3) \
|
||||
|| BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(310))
|
||||
# define BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_PROTO_BROKEN_CONST_OVERLOADS
|
||||
# include <boost/utility/enable_if.hpp>
|
||||
# include <boost/type_traits/is_const.hpp>
|
||||
# define BOOST_PROTO_DISABLE_IF_IS_CONST(T)\
|
||||
, typename boost::disable_if_c<boost::is_const<T>::value, boost::proto::detail::undefined>::type * = 0
|
||||
#else
|
||||
# define BOOST_PROTO_DISABLE_IF_IS_CONST(T)
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS
|
||||
# include <boost/utility/enable_if.hpp>
|
||||
# include <boost/type_traits/is_function.hpp>
|
||||
# define BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)\
|
||||
, typename boost::disable_if_c<boost::is_function<T>::value, boost::proto::detail::undefined>::type * = 0
|
||||
#else
|
||||
# define BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_PROTO_BROKEN_PTS
|
||||
# if BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
|
||||
# define BOOST_PROTO_BROKEN_PTS
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_PROTO_USE_NORMAL_RESULT_OF
|
||||
# define BOOST_PROTO_RESULT_OF boost::result_of
|
||||
#else
|
||||
# define BOOST_PROTO_RESULT_OF boost::tr1_result_of
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING
|
||||
# define BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING
|
||||
#endif
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
typedef char yes_type;
|
||||
typedef char (&no_type)[2];
|
||||
|
||||
template<int N>
|
||||
struct sized_type
|
||||
{
|
||||
typedef char (&type)[N];
|
||||
};
|
||||
|
||||
struct dont_care;
|
||||
struct undefined; // leave this undefined
|
||||
struct not_a_valid_type;
|
||||
|
||||
struct private_type_
|
||||
{
|
||||
private_type_ operator ,(int) const;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct uncvref
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct uncvref<T const>
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct uncvref<T &>
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct uncvref<T const &>
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
struct uncvref<T const[N]>
|
||||
{
|
||||
typedef T type[N];
|
||||
};
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
struct uncvref<T (&)[N]>
|
||||
{
|
||||
typedef T type[N];
|
||||
};
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
struct uncvref<T const (&)[N]>
|
||||
{
|
||||
typedef T type[N];
|
||||
};
|
||||
|
||||
struct ignore
|
||||
{
|
||||
ignore()
|
||||
{}
|
||||
|
||||
template<typename T>
|
||||
ignore(T const &)
|
||||
{}
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_UNCVREF(X) \
|
||||
typename boost::proto::detail::uncvref<X>::type \
|
||||
/**/
|
||||
|
||||
struct _default;
|
||||
|
||||
struct not_a_domain;
|
||||
struct not_a_grammar;
|
||||
struct not_a_generator;
|
||||
|
||||
template<typename T, typename Void = void>
|
||||
struct is_transform_;
|
||||
|
||||
template<typename T, typename Void = void>
|
||||
struct is_aggregate_;
|
||||
}
|
||||
|
||||
typedef detail::ignore const ignore;
|
||||
|
||||
namespace argsns_
|
||||
{
|
||||
template<typename Arg0>
|
||||
struct term;
|
||||
|
||||
#define M0(Z, N, DATA) \
|
||||
template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename Arg)> struct BOOST_PP_CAT(list, N); \
|
||||
/**/
|
||||
BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M0, ~)
|
||||
#undef M0
|
||||
}
|
||||
|
||||
using namespace argsns_;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Operator tags
|
||||
namespace tagns_
|
||||
{
|
||||
namespace tag
|
||||
{
|
||||
struct terminal;
|
||||
struct unary_plus;
|
||||
struct negate;
|
||||
struct dereference;
|
||||
struct complement;
|
||||
struct address_of;
|
||||
struct logical_not;
|
||||
struct pre_inc;
|
||||
struct pre_dec;
|
||||
struct post_inc;
|
||||
struct post_dec;
|
||||
|
||||
struct shift_left;
|
||||
struct shift_right;
|
||||
struct multiplies;
|
||||
struct divides;
|
||||
struct modulus;
|
||||
struct plus;
|
||||
struct minus;
|
||||
struct less;
|
||||
struct greater;
|
||||
struct less_equal;
|
||||
struct greater_equal;
|
||||
struct equal_to;
|
||||
struct not_equal_to;
|
||||
struct logical_or;
|
||||
struct logical_and;
|
||||
struct bitwise_and;
|
||||
struct bitwise_or;
|
||||
struct bitwise_xor;
|
||||
struct comma;
|
||||
struct mem_ptr;
|
||||
|
||||
struct assign;
|
||||
struct shift_left_assign;
|
||||
struct shift_right_assign;
|
||||
struct multiplies_assign;
|
||||
struct divides_assign;
|
||||
struct modulus_assign;
|
||||
struct plus_assign;
|
||||
struct minus_assign;
|
||||
struct bitwise_and_assign;
|
||||
struct bitwise_or_assign;
|
||||
struct bitwise_xor_assign;
|
||||
struct subscript;
|
||||
struct member;
|
||||
struct if_else_;
|
||||
struct function;
|
||||
|
||||
// Fusion tags
|
||||
struct proto_expr;
|
||||
struct proto_expr_iterator;
|
||||
struct proto_flat_view;
|
||||
}
|
||||
}
|
||||
|
||||
using namespace tagns_;
|
||||
|
||||
template<typename Expr>
|
||||
struct tag_of;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
struct _;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
struct default_generator;
|
||||
|
||||
struct basic_default_generator;
|
||||
|
||||
template<template<typename> class Extends>
|
||||
struct generator;
|
||||
|
||||
template<template<typename> class Extends>
|
||||
struct pod_generator;
|
||||
|
||||
struct by_value_generator;
|
||||
|
||||
template<typename First, typename Second>
|
||||
struct compose_generators;
|
||||
|
||||
template<typename Generator, typename Void = void>
|
||||
struct wants_basic_expr;
|
||||
|
||||
template<typename Generator>
|
||||
struct use_basic_expr;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
namespace domainns_
|
||||
{
|
||||
typedef detail::not_a_domain no_super_domain;
|
||||
|
||||
template<
|
||||
typename Generator = default_generator
|
||||
, typename Grammar = proto::_
|
||||
, typename Super = no_super_domain
|
||||
>
|
||||
struct domain;
|
||||
|
||||
struct default_domain;
|
||||
|
||||
struct basic_default_domain;
|
||||
|
||||
struct deduce_domain;
|
||||
|
||||
template<typename Domain, typename Tag, typename Args, bool WantsBasicExpr = wants_basic_expr<typename Domain::proto_generator>::value>
|
||||
struct base_expr;
|
||||
}
|
||||
|
||||
using namespace domainns_;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
namespace exprns_
|
||||
{
|
||||
template<typename Tag, typename Args, long Arity = Args::arity>
|
||||
struct basic_expr;
|
||||
|
||||
template<typename Tag, typename Args, long Arity = Args::arity>
|
||||
struct expr;
|
||||
|
||||
template<
|
||||
typename Expr
|
||||
, typename Derived
|
||||
, typename Domain = default_domain
|
||||
, long Arity = Expr::proto_arity_c
|
||||
>
|
||||
struct extends;
|
||||
|
||||
template<typename This, typename Fun, typename Domain>
|
||||
struct virtual_member;
|
||||
|
||||
struct is_proto_expr;
|
||||
}
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
using exprns_::expr;
|
||||
using exprns_::basic_expr;
|
||||
using exprns_::extends;
|
||||
using exprns_::is_proto_expr;
|
||||
|
||||
template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G, void)>
|
||||
struct or_;
|
||||
|
||||
template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G, void)>
|
||||
struct and_;
|
||||
|
||||
template<typename Grammar>
|
||||
struct not_;
|
||||
|
||||
template<typename Condition, typename Then = _, typename Else = not_<_> >
|
||||
struct if_;
|
||||
|
||||
template<typename Cases, typename Transform = tag_of<_>()>
|
||||
struct switch_;
|
||||
|
||||
template<typename T>
|
||||
struct exact;
|
||||
|
||||
template<typename T>
|
||||
struct convertible_to;
|
||||
|
||||
template<typename Grammar>
|
||||
struct vararg;
|
||||
|
||||
// Boost bug https://svn.boost.org/trac/boost/ticket/4602
|
||||
//int const N = INT_MAX;
|
||||
int const N = (INT_MAX >> 10);
|
||||
|
||||
namespace context
|
||||
{
|
||||
struct null_context;
|
||||
|
||||
template<typename Expr, typename Context, long Arity = Expr::proto_arity_c>
|
||||
struct null_eval;
|
||||
|
||||
struct default_context;
|
||||
|
||||
template<typename Expr, typename Context, typename Tag = typename Expr::proto_tag, long Arity = Expr::proto_arity_c>
|
||||
struct default_eval;
|
||||
|
||||
template<typename Derived, typename DefaultCtx = default_context>
|
||||
struct callable_context;
|
||||
|
||||
template<typename Expr, typename Context, long Arity = Expr::proto_arity_c>
|
||||
struct callable_eval;
|
||||
}
|
||||
|
||||
using context::null_context;
|
||||
using context::null_eval;
|
||||
using context::default_context;
|
||||
using context::default_eval;
|
||||
using context::callable_context;
|
||||
using context::callable_eval;
|
||||
|
||||
namespace utility
|
||||
{
|
||||
template<typename T, typename Domain = default_domain>
|
||||
struct literal;
|
||||
}
|
||||
|
||||
using utility::literal;
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template<typename T, typename Domain = default_domain>
|
||||
struct as_expr;
|
||||
|
||||
template<typename T, typename Domain = default_domain>
|
||||
struct as_child;
|
||||
|
||||
template<typename Expr, typename N = mpl::long_<0> >
|
||||
struct child;
|
||||
|
||||
template<typename Expr, long N>
|
||||
struct child_c;
|
||||
|
||||
template<typename Expr>
|
||||
struct left;
|
||||
|
||||
template<typename Expr>
|
||||
struct right;
|
||||
|
||||
template<typename Expr>
|
||||
struct deep_copy;
|
||||
|
||||
template<typename Expr, typename Context>
|
||||
struct eval;
|
||||
|
||||
template<
|
||||
typename Tag
|
||||
, typename DomainOrA0
|
||||
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(
|
||||
BOOST_PROTO_MAX_ARITY
|
||||
, typename A
|
||||
, = void BOOST_PP_INTERCEPT
|
||||
)
|
||||
, typename Void = void
|
||||
>
|
||||
struct make_expr;
|
||||
|
||||
template<typename Tag, typename DomainOrSequence, typename SequenceOrVoid = void, typename Void = void>
|
||||
struct unpack_expr;
|
||||
|
||||
}
|
||||
|
||||
template<typename T, typename Void = void>
|
||||
struct is_expr;
|
||||
|
||||
template<typename T, typename Void = void>
|
||||
struct is_domain;
|
||||
|
||||
template<typename SubDomain, typename SuperDomain>
|
||||
struct is_sub_domain_of;
|
||||
|
||||
template<typename Expr>
|
||||
struct arity_of;
|
||||
|
||||
template<typename T, typename Void = void>
|
||||
struct domain_of;
|
||||
|
||||
template<typename Expr, typename Grammar>
|
||||
struct matches;
|
||||
|
||||
// Generic expression metafunctions and
|
||||
// grammar elements
|
||||
template<typename Tag, typename Arg>
|
||||
struct unary_expr;
|
||||
|
||||
template<typename Tag, typename Left, typename Right>
|
||||
struct binary_expr;
|
||||
|
||||
template<typename Tag, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY, typename A, void)>
|
||||
struct nary_expr;
|
||||
|
||||
// Specific expression metafunctions and
|
||||
// grammar elements, for convenience
|
||||
template<typename T> struct terminal;
|
||||
template<typename T> struct unary_plus;
|
||||
template<typename T> struct negate;
|
||||
template<typename T> struct dereference;
|
||||
template<typename T> struct complement;
|
||||
template<typename T> struct address_of;
|
||||
template<typename T> struct logical_not;
|
||||
template<typename T> struct pre_inc;
|
||||
template<typename T> struct pre_dec;
|
||||
template<typename T> struct post_inc;
|
||||
template<typename T> struct post_dec;
|
||||
|
||||
template<typename T, typename U> struct shift_left;
|
||||
template<typename T, typename U> struct shift_right;
|
||||
template<typename T, typename U> struct multiplies;
|
||||
template<typename T, typename U> struct divides;
|
||||
template<typename T, typename U> struct modulus;
|
||||
template<typename T, typename U> struct plus;
|
||||
template<typename T, typename U> struct minus;
|
||||
template<typename T, typename U> struct less;
|
||||
template<typename T, typename U> struct greater;
|
||||
template<typename T, typename U> struct less_equal;
|
||||
template<typename T, typename U> struct greater_equal;
|
||||
template<typename T, typename U> struct equal_to;
|
||||
template<typename T, typename U> struct not_equal_to;
|
||||
template<typename T, typename U> struct logical_or;
|
||||
template<typename T, typename U> struct logical_and;
|
||||
template<typename T, typename U> struct bitwise_and;
|
||||
template<typename T, typename U> struct bitwise_or;
|
||||
template<typename T, typename U> struct bitwise_xor;
|
||||
template<typename T, typename U> struct comma;
|
||||
template<typename T, typename U> struct mem_ptr;
|
||||
|
||||
template<typename T, typename U> struct assign;
|
||||
template<typename T, typename U> struct shift_left_assign;
|
||||
template<typename T, typename U> struct shift_right_assign;
|
||||
template<typename T, typename U> struct multiplies_assign;
|
||||
template<typename T, typename U> struct divides_assign;
|
||||
template<typename T, typename U> struct modulus_assign;
|
||||
template<typename T, typename U> struct plus_assign;
|
||||
template<typename T, typename U> struct minus_assign;
|
||||
template<typename T, typename U> struct bitwise_and_assign;
|
||||
template<typename T, typename U> struct bitwise_or_assign;
|
||||
template<typename T, typename U> struct bitwise_xor_assign;
|
||||
template<typename T, typename U> struct subscript;
|
||||
template<typename T, typename U> struct member;
|
||||
template<typename T, typename U, typename V> struct if_else_;
|
||||
|
||||
template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY, typename A, void)>
|
||||
struct function;
|
||||
|
||||
namespace functional
|
||||
{
|
||||
struct left;
|
||||
struct right;
|
||||
struct eval;
|
||||
struct deep_copy;
|
||||
|
||||
template<typename Domain = default_domain>
|
||||
struct as_expr;
|
||||
|
||||
template<typename Domain = default_domain>
|
||||
struct as_child;
|
||||
|
||||
template<typename N = mpl::long_<0> >
|
||||
struct child;
|
||||
|
||||
template<long N>
|
||||
struct child_c;
|
||||
|
||||
template<typename Tag, typename Domain = deduce_domain>
|
||||
struct make_expr;
|
||||
|
||||
template<typename Tag, typename Domain = deduce_domain>
|
||||
struct unpack_expr;
|
||||
|
||||
typedef make_expr<tag::terminal> make_terminal;
|
||||
typedef make_expr<tag::unary_plus> make_unary_plus;
|
||||
typedef make_expr<tag::negate> make_negate;
|
||||
typedef make_expr<tag::dereference> make_dereference;
|
||||
typedef make_expr<tag::complement> make_complement;
|
||||
typedef make_expr<tag::address_of> make_address_of;
|
||||
typedef make_expr<tag::logical_not> make_logical_not;
|
||||
typedef make_expr<tag::pre_inc> make_pre_inc;
|
||||
typedef make_expr<tag::pre_dec> make_pre_dec;
|
||||
typedef make_expr<tag::post_inc> make_post_inc;
|
||||
typedef make_expr<tag::post_dec> make_post_dec;
|
||||
typedef make_expr<tag::shift_left> make_shift_left;
|
||||
typedef make_expr<tag::shift_right> make_shift_right;
|
||||
typedef make_expr<tag::multiplies> make_multiplies;
|
||||
typedef make_expr<tag::divides> make_divides;
|
||||
typedef make_expr<tag::modulus> make_modulus;
|
||||
typedef make_expr<tag::plus> make_plus;
|
||||
typedef make_expr<tag::minus> make_minus;
|
||||
typedef make_expr<tag::less> make_less;
|
||||
typedef make_expr<tag::greater> make_greater;
|
||||
typedef make_expr<tag::less_equal> make_less_equal;
|
||||
typedef make_expr<tag::greater_equal> make_greater_equal;
|
||||
typedef make_expr<tag::equal_to> make_equal_to;
|
||||
typedef make_expr<tag::not_equal_to> make_not_equal_to;
|
||||
typedef make_expr<tag::logical_or> make_logical_or;
|
||||
typedef make_expr<tag::logical_and> make_logical_and;
|
||||
typedef make_expr<tag::bitwise_and> make_bitwise_and;
|
||||
typedef make_expr<tag::bitwise_or> make_bitwise_or;
|
||||
typedef make_expr<tag::bitwise_xor> make_bitwise_xor;
|
||||
typedef make_expr<tag::comma> make_comma;
|
||||
typedef make_expr<tag::mem_ptr> make_mem_ptr;
|
||||
typedef make_expr<tag::assign> make_assign;
|
||||
typedef make_expr<tag::shift_left_assign> make_shift_left_assign;
|
||||
typedef make_expr<tag::shift_right_assign> make_shift_right_assign;
|
||||
typedef make_expr<tag::multiplies_assign> make_multiplies_assign;
|
||||
typedef make_expr<tag::divides_assign> make_divides_assign;
|
||||
typedef make_expr<tag::modulus_assign> make_modulus_assign;
|
||||
typedef make_expr<tag::plus_assign> make_plus_assign;
|
||||
typedef make_expr<tag::minus_assign> make_minus_assign;
|
||||
typedef make_expr<tag::bitwise_and_assign> make_bitwise_and_assign;
|
||||
typedef make_expr<tag::bitwise_or_assign> make_bitwise_or_assign;
|
||||
typedef make_expr<tag::bitwise_xor_assign> make_bitwise_xor_assign;
|
||||
typedef make_expr<tag::subscript> make_subscript;
|
||||
typedef make_expr<tag::if_else_> make_if_else;
|
||||
typedef make_expr<tag::function> make_function;
|
||||
|
||||
struct flatten;
|
||||
struct make_pair;
|
||||
struct first;
|
||||
struct second;
|
||||
struct at;
|
||||
struct pop_front;
|
||||
struct push_front;
|
||||
struct pop_back;
|
||||
struct push_back;
|
||||
struct reverse;
|
||||
}
|
||||
|
||||
typedef functional::flatten _flatten;
|
||||
typedef functional::make_pair _make_pair;
|
||||
typedef functional::first _first;
|
||||
typedef functional::second _second;
|
||||
typedef functional::pop_front _at;
|
||||
typedef functional::pop_front _pop_front;
|
||||
typedef functional::push_front _push_front;
|
||||
typedef functional::pop_back _pop_back;
|
||||
typedef functional::push_back _push_back;
|
||||
typedef functional::reverse _reverse;
|
||||
typedef functional::eval _eval;
|
||||
struct _deep_copy;
|
||||
|
||||
typedef functional::make_expr<tag::terminal> _make_terminal;
|
||||
typedef functional::make_expr<tag::unary_plus> _make_unary_plus;
|
||||
typedef functional::make_expr<tag::negate> _make_negate;
|
||||
typedef functional::make_expr<tag::dereference> _make_dereference;
|
||||
typedef functional::make_expr<tag::complement> _make_complement;
|
||||
typedef functional::make_expr<tag::address_of> _make_address_of;
|
||||
typedef functional::make_expr<tag::logical_not> _make_logical_not;
|
||||
typedef functional::make_expr<tag::pre_inc> _make_pre_inc;
|
||||
typedef functional::make_expr<tag::pre_dec> _make_pre_dec;
|
||||
typedef functional::make_expr<tag::post_inc> _make_post_inc;
|
||||
typedef functional::make_expr<tag::post_dec> _make_post_dec;
|
||||
typedef functional::make_expr<tag::shift_left> _make_shift_left;
|
||||
typedef functional::make_expr<tag::shift_right> _make_shift_right;
|
||||
typedef functional::make_expr<tag::multiplies> _make_multiplies;
|
||||
typedef functional::make_expr<tag::divides> _make_divides;
|
||||
typedef functional::make_expr<tag::modulus> _make_modulus;
|
||||
typedef functional::make_expr<tag::plus> _make_plus;
|
||||
typedef functional::make_expr<tag::minus> _make_minus;
|
||||
typedef functional::make_expr<tag::less> _make_less;
|
||||
typedef functional::make_expr<tag::greater> _make_greater;
|
||||
typedef functional::make_expr<tag::less_equal> _make_less_equal;
|
||||
typedef functional::make_expr<tag::greater_equal> _make_greater_equal;
|
||||
typedef functional::make_expr<tag::equal_to> _make_equal_to;
|
||||
typedef functional::make_expr<tag::not_equal_to> _make_not_equal_to;
|
||||
typedef functional::make_expr<tag::logical_or> _make_logical_or;
|
||||
typedef functional::make_expr<tag::logical_and> _make_logical_and;
|
||||
typedef functional::make_expr<tag::bitwise_and> _make_bitwise_and;
|
||||
typedef functional::make_expr<tag::bitwise_or> _make_bitwise_or;
|
||||
typedef functional::make_expr<tag::bitwise_xor> _make_bitwise_xor;
|
||||
typedef functional::make_expr<tag::comma> _make_comma;
|
||||
typedef functional::make_expr<tag::mem_ptr> _make_mem_ptr;
|
||||
typedef functional::make_expr<tag::assign> _make_assign;
|
||||
typedef functional::make_expr<tag::shift_left_assign> _make_shift_left_assign;
|
||||
typedef functional::make_expr<tag::shift_right_assign> _make_shift_right_assign;
|
||||
typedef functional::make_expr<tag::multiplies_assign> _make_multiplies_assign;
|
||||
typedef functional::make_expr<tag::divides_assign> _make_divides_assign;
|
||||
typedef functional::make_expr<tag::modulus_assign> _make_modulus_assign;
|
||||
typedef functional::make_expr<tag::plus_assign> _make_plus_assign;
|
||||
typedef functional::make_expr<tag::minus_assign> _make_minus_assign;
|
||||
typedef functional::make_expr<tag::bitwise_and_assign> _make_bitwise_and_assign;
|
||||
typedef functional::make_expr<tag::bitwise_or_assign> _make_bitwise_or_assign;
|
||||
typedef functional::make_expr<tag::bitwise_xor_assign> _make_bitwise_xor_assign;
|
||||
typedef functional::make_expr<tag::subscript> _make_subscript;
|
||||
typedef functional::make_expr<tag::if_else_> _make_if_else;
|
||||
typedef functional::make_expr<tag::function> _make_function;
|
||||
|
||||
template<typename T>
|
||||
struct is_callable;
|
||||
|
||||
template<typename T>
|
||||
struct is_transform;
|
||||
|
||||
template<typename T>
|
||||
struct is_aggregate;
|
||||
|
||||
#define BOOST_PROTO_UNEXPR() typedef int proto_is_expr_;
|
||||
#define BOOST_PROTO_CALLABLE() typedef void proto_is_callable_;
|
||||
#define BOOST_PROTO_AGGREGATE() typedef void proto_is_aggregate_;
|
||||
#define BOOST_PROTO_USE_BASIC_EXPR() typedef void proto_use_basic_expr_;
|
||||
|
||||
struct callable
|
||||
{
|
||||
BOOST_PROTO_CALLABLE()
|
||||
};
|
||||
|
||||
struct external_transform;
|
||||
|
||||
template<typename PrimitiveTransform = void, typename X = void>
|
||||
struct transform;
|
||||
|
||||
template<typename Grammar, typename Fun = Grammar>
|
||||
struct when;
|
||||
|
||||
template<typename Fun>
|
||||
struct otherwise;
|
||||
|
||||
template<typename Fun>
|
||||
struct call;
|
||||
|
||||
template<typename Fun>
|
||||
struct make;
|
||||
|
||||
template<typename PrimitiveTransform>
|
||||
struct protect;
|
||||
|
||||
template<typename T>
|
||||
struct noinvoke;
|
||||
|
||||
template<typename Fun>
|
||||
struct lazy;
|
||||
|
||||
template<typename Sequence, typename State, typename Fun>
|
||||
struct fold;
|
||||
|
||||
template<typename Sequence, typename State, typename Fun>
|
||||
struct reverse_fold;
|
||||
|
||||
// Q: can we replace fold_tree with fold<flatten(_), state, fun> ?
|
||||
// A: once segmented Fusion works well.
|
||||
template<typename Sequence, typename State, typename Fun>
|
||||
struct fold_tree;
|
||||
|
||||
template<typename Sequence, typename State, typename Fun>
|
||||
struct reverse_fold_tree;
|
||||
|
||||
template<typename Grammar>
|
||||
struct pass_through;
|
||||
|
||||
template<typename Grammar = detail::_default>
|
||||
struct _default;
|
||||
|
||||
struct _expr;
|
||||
struct _state;
|
||||
struct _data;
|
||||
|
||||
struct _value;
|
||||
|
||||
struct _void;
|
||||
|
||||
template<typename T, T I>
|
||||
struct integral_c;
|
||||
|
||||
template<char I>
|
||||
struct char_;
|
||||
|
||||
template<int I>
|
||||
struct int_;
|
||||
|
||||
template<long I>
|
||||
struct long_;
|
||||
|
||||
template<std::size_t I>
|
||||
struct size_t;
|
||||
|
||||
template<int I>
|
||||
struct _child_c;
|
||||
|
||||
typedef _child_c<0> _child0;
|
||||
typedef _child_c<1> _child1;
|
||||
typedef _child0 _child;
|
||||
typedef _child0 _left;
|
||||
typedef _child1 _right;
|
||||
|
||||
// _child2, _child3, _child4, ...
|
||||
#define M0(Z, N, DATA) typedef _child_c<N> BOOST_PP_CAT(_child, N);
|
||||
BOOST_PP_REPEAT_FROM_TO(
|
||||
2
|
||||
, BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY)
|
||||
, M0
|
||||
, ~
|
||||
)
|
||||
#undef M0
|
||||
|
||||
struct _byref;
|
||||
struct _byval;
|
||||
|
||||
template<typename T>
|
||||
struct is_extension;
|
||||
|
||||
//namespace exops
|
||||
//{}
|
||||
|
||||
namespace exops = exprns_;
|
||||
|
||||
}} // namespace boost::proto
|
||||
|
||||
#endif
|
||||
139
test/external/boost/proto/proto_typeof.hpp
vendored
Normal file
139
test/external/boost/proto/proto_typeof.hpp
vendored
Normal file
@@ -0,0 +1,139 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file proto_typeof.hpp
|
||||
/// Type registrations so that proto expression templates can be used together
|
||||
/// with the Boost.Typeof library.
|
||||
//
|
||||
// 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_XPRESSIVE_PROTO_PROTO_TYPEOF_H
|
||||
#define BOOST_XPRESSIVE_PROTO_PROTO_TYPEOF_H
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/typeof/typeof.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/deep_copy.hpp>
|
||||
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
|
||||
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::terminal)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::unary_plus)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::negate)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::dereference)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::complement)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::address_of)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::logical_not)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::pre_inc)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::pre_dec)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::post_inc)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::post_dec)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::shift_left)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::shift_right)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::multiplies)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::divides)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::modulus)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::plus)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::minus)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::less)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::greater)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::less_equal)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::greater_equal)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::equal_to)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::not_equal_to)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::logical_or)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::logical_and)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitwise_and)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitwise_or)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitwise_xor)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::comma)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::mem_ptr)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::assign)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::shift_left_assign)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::shift_right_assign)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::multiplies_assign)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::divides_assign)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::modulus_assign)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::plus_assign)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::minus_assign)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitwise_and_assign)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitwise_or_assign)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitwise_xor_assign)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::subscript)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::member)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::if_else_)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::function)
|
||||
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::exprns_::is_proto_expr)
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::exprns_::expr, (typename)(typename)(long))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::exprns_::basic_expr, (typename)(typename)(long))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::utility::literal, (typename)(typename))
|
||||
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::detail::not_a_generator)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::detail::not_a_grammar)
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::detail::not_a_domain)
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::domain, 3)
|
||||
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::term, 1)
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list1, 1)
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list2, 2)
|
||||
// can't use PP metaprogramming here because all typeof registrations
|
||||
// must be on separate lines.
|
||||
#if BOOST_PROTO_MAX_ARITY >= 3
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list3, 3)
|
||||
#endif
|
||||
#if BOOST_PROTO_MAX_ARITY >= 4
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list4, 4)
|
||||
#endif
|
||||
#if BOOST_PROTO_MAX_ARITY >= 5
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list5, 5)
|
||||
#endif
|
||||
#if BOOST_PROTO_MAX_ARITY >= 6
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list6, 6)
|
||||
#endif
|
||||
#if BOOST_PROTO_MAX_ARITY >= 7
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list7, 7)
|
||||
#endif
|
||||
#if BOOST_PROTO_MAX_ARITY >= 8
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list8, 8)
|
||||
#endif
|
||||
#if BOOST_PROTO_MAX_ARITY >= 9
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list9, 9)
|
||||
#endif
|
||||
#if BOOST_PROTO_MAX_ARITY >= 10
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list10, 10)
|
||||
#endif
|
||||
#if BOOST_PROTO_MAX_ARITY >= 11
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list11, 11)
|
||||
#endif
|
||||
#if BOOST_PROTO_MAX_ARITY >= 12
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list12, 12)
|
||||
#endif
|
||||
#if BOOST_PROTO_MAX_ARITY >= 13
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list13, 13)
|
||||
#endif
|
||||
#if BOOST_PROTO_MAX_ARITY >= 14
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list14, 14)
|
||||
#endif
|
||||
#if BOOST_PROTO_MAX_ARITY >= 15
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list15, 15)
|
||||
#endif
|
||||
#if BOOST_PROTO_MAX_ARITY >= 16
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list16, 16)
|
||||
#endif
|
||||
#if BOOST_PROTO_MAX_ARITY >= 17
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list17, 17)
|
||||
#endif
|
||||
#if BOOST_PROTO_MAX_ARITY >= 18
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list18, 18)
|
||||
#endif
|
||||
#if BOOST_PROTO_MAX_ARITY >= 19
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list19, 19)
|
||||
#endif
|
||||
#if BOOST_PROTO_MAX_ARITY >= 20
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list20, 20)
|
||||
#endif
|
||||
|
||||
#define BOOST_PROTO_AUTO(Var, Expr) BOOST_AUTO(Var, boost::proto::deep_copy(Expr))
|
||||
#define BOOST_PROTO_AUTO_TPL(Var, Expr) BOOST_AUTO_TPL(Var, boost::proto::deep_copy(Expr))
|
||||
|
||||
#endif
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user