#include <boost/config.hpp>
#include <boost/detail/workaround.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/repeat.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/preprocessor/facilities/intercept.hpp>
#include <boost/preprocessor/arithmetic/sub.hpp>
#include <boost/static_assert.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/proto/detail/template_arity.hpp>
#include <boost/type_traits/is_pod.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/args.hpp>
#include <boost/proto/domain.hpp>
#include <boost/proto/transform/pass_through.hpp>
#include <boost/proto/detail/traits.hpp>

Include dependency graph for traits.hpp:

This graph shows which files directly or indirectly include this file:

Classes
struct	boost::proto::detail::if_vararg< T, Void >

struct	boost::proto::detail::if_vararg< T, typename T::proto_is_vararg_ >

struct	boost::proto::detail::is_callable2_< T, Void >

struct	boost::proto::detail::is_callable2_< T, typename T::proto_is_callable_ >

struct	boost::proto::detail::is_callable_< BOOST_PROTO_TEMPLATE_ARITY_PARAM >

struct	boost::proto::is_callable< T >
	Boolean metafunction which detects whether a type is a callable function object type or not. More...

struct	boost::proto::is_callable< proto::_ >
	INTERNAL ONLY. More...

struct	boost::proto::is_callable< proto::callable >
	INTERNAL ONLY. More...

struct	boost::proto::is_callable< proto::transform< PrimitiveTransform, X > >
	INTERNAL ONLY. More...

struct	boost::proto::detail::is_transform_< T, Void >

struct	boost::proto::detail::is_transform_< T, typename T::proto_is_transform_ >

struct	boost::proto::is_transform< T >
	Boolean metafunction which detects whether a type is a PrimitiveTransform type or not. More...

struct	boost::proto::detail::is_aggregate_< T, Void >

struct	boost::proto::detail::is_aggregate_< proto::expr< Tag, Args, N >, void >

struct	boost::proto::detail::is_aggregate_< proto::basic_expr< Tag, Args, N >, void >

struct	boost::proto::detail::is_aggregate_< T, typename T::proto_is_aggregate_ >

struct	boost::proto::is_aggregate< T >
	A Boolean metafunction that indicates whether a type requires aggregate initialization. More...

struct	boost::proto::is_expr< T, Void >
	A Boolean metafunction that indicates whether a given type `T` is a Proto expression type. More...

struct	boost::proto::is_expr< T, typename T::proto_is_expr_ >
	A Boolean metafunction that indicates whether a given type `T` is a Proto expression type. More...

struct	boost::proto::is_expr< T &, void >

struct	boost::proto::tag_of< Expr >
	A metafunction that returns the tag type of a Proto expression. More...

struct	boost::proto::tag_of< Expr & >

struct	boost::proto::arity_of< Expr >
	A metafunction that returns the arity of a Proto expression. More...

struct	boost::proto::arity_of< Expr & >

struct	boost::proto::result_of::as_expr< T, Domain >
	A metafunction that computes the return type of the `as_expr()` function. More...

struct	boost::proto::result_of::as_child< T, Domain >
	A metafunction that computes the return type of the `as_child()` function. More...

struct	boost::proto::result_of::child< Expr, N >
	A metafunction that returns the type of the Nth child of a Proto expression, where N is an MPL Integral Constant. More...

struct	boost::proto::result_of::value< Expr >
	A metafunction that returns the type of the value of a terminal Proto expression. More...

struct	boost::proto::result_of::value< Expr & >

struct	boost::proto::result_of::value< Expr const & >

struct	boost::proto::result_of::left< Expr >
	A metafunction that returns the type of the left child of a binary Proto expression. More...

struct	boost::proto::result_of::right< Expr >
	A metafunction that returns the type of the right child of a binary Proto expression. More...

struct	boost::proto::terminal< T >
	A metafunction for generating terminal expression types, a grammar element for matching terminal expressions, and a PrimitiveTransform that returns the current expression unchanged. More...

struct	boost::proto::terminal< T >::impl< Expr, State, Data >

struct	boost::proto::if_else_< T, U, V >
	A metafunction for generating ternary conditional expression types, a grammar element for matching ternary conditional expressions, and a PrimitiveTransform that dispatches to the `pass_through<>` transform. More...

struct	boost::proto::if_else_< T, U, V >::impl< Expr, State, Data >

struct	boost::proto::nullary_expr< Tag, T >
	A metafunction for generating nullary expression types with a specified tag type, a grammar element for matching nullary expressions, and a PrimitiveTransform that returns the current expression unchanged. More...

struct	boost::proto::nullary_expr< Tag, T >::impl< Expr, State, Data >

struct	boost::proto::unary_expr< Tag, T >
	A metafunction for generating unary expression types with a specified tag type, a grammar element for matching unary expressions, and a PrimitiveTransform that dispatches to the `pass_through<>` transform. More...

struct	boost::proto::unary_expr< Tag, T >::impl< Expr, State, Data >

struct	boost::proto::binary_expr< Tag, T, U >
	A metafunction for generating binary expression types with a specified tag type, a grammar element for matching binary expressions, and a PrimitiveTransform that dispatches to the `pass_through<>` transform. More...

struct	boost::proto::binary_expr< Tag, T, U >::impl< Expr, State, Data >

struct	boost::proto::unary_plus< T >

struct	boost::proto::unary_plus< T >::impl< Expr, State, Data >

struct	boost::proto::negate< T >

struct	boost::proto::negate< T >::impl< Expr, State, Data >

struct	boost::proto::dereference< T >

struct	boost::proto::dereference< T >::impl< Expr, State, Data >

struct	boost::proto::complement< T >

struct	boost::proto::complement< T >::impl< Expr, State, Data >

struct	boost::proto::address_of< T >

struct	boost::proto::address_of< T >::impl< Expr, State, Data >

struct	boost::proto::logical_not< T >

struct	boost::proto::logical_not< T >::impl< Expr, State, Data >

struct	boost::proto::pre_inc< T >

struct	boost::proto::pre_inc< T >::impl< Expr, State, Data >

struct	boost::proto::pre_dec< T >

struct	boost::proto::pre_dec< T >::impl< Expr, State, Data >

struct	boost::proto::post_inc< T >

struct	boost::proto::post_inc< T >::impl< Expr, State, Data >

struct	boost::proto::post_dec< T >

struct	boost::proto::post_dec< T >::impl< Expr, State, Data >

struct	boost::proto::shift_left< T, U >

struct	boost::proto::shift_left< T, U >::impl< Expr, State, Data >

struct	boost::proto::shift_right< T, U >

struct	boost::proto::shift_right< T, U >::impl< Expr, State, Data >

struct	boost::proto::multiplies< T, U >

struct	boost::proto::multiplies< T, U >::impl< Expr, State, Data >

struct	boost::proto::divides< T, U >

struct	boost::proto::divides< T, U >::impl< Expr, State, Data >

struct	boost::proto::modulus< T, U >

struct	boost::proto::modulus< T, U >::impl< Expr, State, Data >

struct	boost::proto::plus< T, U >

struct	boost::proto::plus< T, U >::impl< Expr, State, Data >

struct	boost::proto::minus< T, U >

struct	boost::proto::minus< T, U >::impl< Expr, State, Data >

struct	boost::proto::less< T, U >

struct	boost::proto::less< T, U >::impl< Expr, State, Data >

struct	boost::proto::greater< T, U >

struct	boost::proto::greater< T, U >::impl< Expr, State, Data >

struct	boost::proto::less_equal< T, U >

struct	boost::proto::less_equal< T, U >::impl< Expr, State, Data >

struct	boost::proto::greater_equal< T, U >

struct	boost::proto::greater_equal< T, U >::impl< Expr, State, Data >

struct	boost::proto::equal_to< T, U >

struct	boost::proto::equal_to< T, U >::impl< Expr, State, Data >

struct	boost::proto::not_equal_to< T, U >

struct	boost::proto::not_equal_to< T, U >::impl< Expr, State, Data >

struct	boost::proto::logical_or< T, U >

struct	boost::proto::logical_or< T, U >::impl< Expr, State, Data >

struct	boost::proto::logical_and< T, U >

struct	boost::proto::logical_and< T, U >::impl< Expr, State, Data >

struct	boost::proto::bitwise_or< T, U >

struct	boost::proto::bitwise_or< T, U >::impl< Expr, State, Data >

struct	boost::proto::bitwise_and< T, U >

struct	boost::proto::bitwise_and< T, U >::impl< Expr, State, Data >

struct	boost::proto::bitwise_xor< T, U >

struct	boost::proto::bitwise_xor< T, U >::impl< Expr, State, Data >

struct	boost::proto::comma< T, U >

struct	boost::proto::comma< T, U >::impl< Expr, State, Data >

struct	boost::proto::mem_ptr< T, U >

struct	boost::proto::mem_ptr< T, U >::impl< Expr, State, Data >

struct	boost::proto::assign< T, U >

struct	boost::proto::assign< T, U >::impl< Expr, State, Data >

struct	boost::proto::shift_left_assign< T, U >

struct	boost::proto::shift_left_assign< T, U >::impl< Expr, State, Data >

struct	boost::proto::shift_right_assign< T, U >

struct	boost::proto::shift_right_assign< T, U >::impl< Expr, State, Data >

struct	boost::proto::multiplies_assign< T, U >

struct	boost::proto::multiplies_assign< T, U >::impl< Expr, State, Data >

struct	boost::proto::divides_assign< T, U >

struct	boost::proto::divides_assign< T, U >::impl< Expr, State, Data >

struct	boost::proto::modulus_assign< T, U >

struct	boost::proto::modulus_assign< T, U >::impl< Expr, State, Data >

struct	boost::proto::plus_assign< T, U >

struct	boost::proto::plus_assign< T, U >::impl< Expr, State, Data >

struct	boost::proto::minus_assign< T, U >

struct	boost::proto::minus_assign< T, U >::impl< Expr, State, Data >

struct	boost::proto::bitwise_or_assign< T, U >

struct	boost::proto::bitwise_or_assign< T, U >::impl< Expr, State, Data >

struct	boost::proto::bitwise_and_assign< T, U >

struct	boost::proto::bitwise_and_assign< T, U >::impl< Expr, State, Data >

struct	boost::proto::bitwise_xor_assign< T, U >

struct	boost::proto::bitwise_xor_assign< T, U >::impl< Expr, State, Data >

struct	boost::proto::subscript< T, U >

struct	boost::proto::subscript< T, U >::impl< Expr, State, Data >

struct	boost::proto::member< T, U >

struct	boost::proto::member< T, U >::impl< Expr, State, Data >

struct	boost::proto::functional::as_expr< Domain >
	A callable PolymorphicFunctionObject that is equivalent to the `as_expr()` function. More...

struct	boost::proto::functional::as_expr< Domain >::result< Sig >

struct	boost::proto::functional::as_expr< Domain >::result< This(T)>

struct	boost::proto::functional::as_expr< Domain >::result< This(T &)>

struct	boost::proto::functional::as_child< Domain >
	A callable PolymorphicFunctionObject that is equivalent to the `as_child()` function. More...

struct	boost::proto::functional::as_child< Domain >::result< Sig >

struct	boost::proto::functional::as_child< Domain >::result< This(T)>

struct	boost::proto::functional::as_child< Domain >::result< This(T &)>

struct	boost::proto::functional::child_c< N >
	A callable PolymorphicFunctionObject that is equivalent to the `child_c()` function. More...

struct	boost::proto::functional::child_c< N >::result< Sig >

struct	boost::proto::functional::child_c< N >::result< This(Expr)>

struct	boost::proto::functional::child< N >
	A callable PolymorphicFunctionObject that is equivalent to the `child()` function. More...

struct	boost::proto::functional::child< N >::result< Sig >

struct	boost::proto::functional::child< N >::result< This(Expr)>

struct	boost::proto::functional::value
	A callable PolymorphicFunctionObject that is equivalent to the `value()` function. More...

struct	boost::proto::functional::value::result< Sig >

struct	boost::proto::functional::value::result< This(Expr)>

struct	boost::proto::functional::left
	A callable PolymorphicFunctionObject that is equivalent to the `left()` function. More...

struct	boost::proto::functional::left::result< Sig >

struct	boost::proto::functional::left::result< This(Expr)>

struct	boost::proto::functional::right
	A callable PolymorphicFunctionObject that is equivalent to the `right()` function. More...

struct	boost::proto::functional::right::result< Sig >

struct	boost::proto::functional::right::result< This(Expr)>

struct	boost::proto::is_callable< functional::as_expr< Domain > >
	INTERNAL ONLY. More...

struct	boost::proto::is_callable< functional::as_child< Domain > >
	INTERNAL ONLY. More...

struct	boost::proto::is_callable< functional::child_c< N > >
	INTERNAL ONLY. More...

struct	boost::proto::is_callable< functional::child< N > >
	INTERNAL ONLY. More...

Namespaces
	boost
	Duration formatting facet for input.

	boost::proto

	boost::proto::detail

	boost::proto::result_of

	boost::proto::functional

Macros
#define	BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(Op)

#define	BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(Op)

Functions
template<typename T >
BOOST_FORCEINLINE add_const < typename result_of::as_expr < T, default_domain >::type > ::type	boost::proto::as_expr (T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T) BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T))
	A function that wraps non-Proto expression types in Proto terminals and leaves Proto expression types alone. More...

template<typename T >
BOOST_FORCEINLINE add_const < typename result_of::as_expr < T const, default_domain > ::type >::type	boost::proto::as_expr (T const &t)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename Domain , typename T >
BOOST_FORCEINLINE add_const < typename result_of::as_expr < T, Domain >::type >::type	boost::proto::as_expr (T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T) BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T))
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename Domain , typename T >
BOOST_FORCEINLINE add_const < typename result_of::as_expr < T const, Domain >::type > ::type	boost::proto::as_expr (T const &t)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename T >
BOOST_FORCEINLINE add_const < typename result_of::as_child < T, default_domain >::type > ::type	boost::proto::as_child (T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T) BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T))
	A function that wraps non-Proto expression types in Proto terminals (by reference) and returns Proto expression types by reference. More...

template<typename T >
BOOST_FORCEINLINE add_const < typename result_of::as_child < T const, default_domain > ::type >::type	boost::proto::as_child (T const &t)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename Domain , typename T >
BOOST_FORCEINLINE add_const < typename result_of::as_child < T, Domain >::type >::type	boost::proto::as_child (T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T) BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T))
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename Domain , typename T >
BOOST_FORCEINLINE add_const < typename result_of::as_child < T const, Domain >::type > ::type	boost::proto::as_child (T const &t)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename N , typename Expr >
BOOST_FORCEINLINE result_of::child< Expr &, N > ::type	boost::proto::child (Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr))
	Return the Nth child of the specified Proto expression. More...

template<typename N , typename Expr >
BOOST_FORCEINLINE result_of::child< Expr const &, N >::type	boost::proto::child (Expr const &e)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename Expr2 >
BOOST_FORCEINLINE detail::expr_traits< typename Expr2::proto_base_expr::proto_child0 > ::reference	boost::proto::child (Expr2 &expr2 BOOST_PROTO_DISABLE_IF_IS_CONST(Expr2))
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename Expr2 >
BOOST_FORCEINLINE detail::expr_traits< typename Expr2::proto_base_expr::proto_child0 > ::const_reference	boost::proto::child (Expr2 const &expr2)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<long N, typename Expr >
BOOST_FORCEINLINE result_of::child_c< Expr &, N > ::type	boost::proto::child_c (Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr))
	Return the Nth child of the specified Proto expression. More...

template<long N, typename Expr >
BOOST_FORCEINLINE result_of::child_c< Expr const &, N >::type	boost::proto::child_c (Expr const &e)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename Expr >
BOOST_FORCEINLINE result_of::value< Expr & > ::type	boost::proto::value (Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr))
	Return the value stored within the specified Proto terminal expression. More...

template<typename Expr >
BOOST_FORCEINLINE result_of::value< Expr const & > ::type	boost::proto::value (Expr const &e)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename Expr >
BOOST_FORCEINLINE result_of::left< Expr & > ::type	boost::proto::left (Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr))
	Return the left child of the specified binary Proto expression. More...

template<typename Expr >
BOOST_FORCEINLINE result_of::left< Expr const & > ::type	boost::proto::left (Expr const &e)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename Expr >
BOOST_FORCEINLINE result_of::right< Expr & > ::type	boost::proto::right (Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr))
	Return the right child of the specified binary Proto expression. More...

template<typename Expr >
BOOST_FORCEINLINE result_of::right< Expr const & > ::type	boost::proto::right (Expr const &e)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

Macro Definition Documentation

#define BOOST_PROTO_DEFINE_BINARY_METAFUNCTION ( Op )

Value:

template<typename T, typename U>                                                            \
    struct Op                                                                                   \
      : proto::transform<Op<T, U>, int>                                                         \
    {                                                                                           \
        typedef proto::expr<proto::tag::Op, list2<T, U>, 2> type;                               \
        typedef proto::basic_expr<proto::tag::Op, list2<T, U>, 2> proto_grammar;                \
                                                                                                \
        template<typename Expr, typename State, typename Data>                                  \
        struct impl                                                                             \
          : detail::pass_through_impl<Op, deduce_domain, Expr, State, Data>                     \
        {};                                                                                     \
                                                                                                \
        typedef proto::tag::Op proto_tag;                                                       \
        typedef T proto_child0;                                                                 \
        typedef U proto_child1;                                                                 \
    };                                                                                          \

#define BOOST_PROTO_DEFINE_UNARY_METAFUNCTION ( Op )

Value:

template<typename T>                                                                        \
    struct Op                                                                                   \
      : proto::transform<Op<T>, int>                                                            \
    {                                                                                           \
        typedef proto::expr<proto::tag::Op, list1<T>, 1> type;                                  \
        typedef proto::basic_expr<proto::tag::Op, list1<T>, 1> proto_grammar;                   \
                                                                                                \
        template<typename Expr, typename State, typename Data>                                  \
        struct impl                                                                             \
          : detail::pass_through_impl<Op, deduce_domain, Expr, State, Data>                     \
        {};                                                                                     \
                                                                                                \
        typedef proto::tag::Op proto_tag;                                                       \
        typedef T proto_child0;                                                                 \
    };                                                                                          \

Classes

Namespaces

Macros

Functions

Macro Definition Documentation