...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
proto::_
proto::_byref
proto::_byval
proto::_child_c
proto::_data
proto::_default
proto::_expr
proto::_state
proto::_value
proto::address_of
proto::and_
proto::arity_of
proto::assign
proto::binary_expr
proto::bitwise_and
proto::bitwise_and_assign
proto::bitwise_or
proto::bitwise_or_assign
proto::bitwise_xor
proto::bitwise_xor_assign
proto::by_value_generator
proto::call
proto::callable
proto::comma
proto::complement
proto::compose_generators
proto::context::callable_context
proto::context::callable_eval
proto::context::default_context
proto::context::default_eval
proto::context::null_context
proto::context::null_eval
proto::convertible_to
proto::deduce_domain
proto::default_domain
proto::default_generator
proto::dereference
proto::divides
proto::divides_assign
proto::domain
proto::domain_of
proto::equal_to
proto::exact
proto::expr
proto::extends
proto::fold
proto::fold_tree
proto::function
proto::functional::as_child
proto::functional::as_expr
proto::functional::child
proto::functional::child_c
proto::functional::deep_copy
proto::functional::display_expr
proto::functional::eval
proto::functional::flatten
proto::functional::left
proto::functional::make_expr
proto::functional::pop_front
proto::functional::reverse
proto::functional::right
proto::functional::unpack_expr
proto::functional::value
proto::generator
proto::greater
proto::greater_equal
proto::if_
proto::if_else_
proto::is_aggregate
proto::is_callable
proto::is_domain
proto::is_expr
proto::is_extension
proto::is_proto_expr
proto::lazy
proto::less
proto::less_equal
proto::list1<>, proto::list2<>, ...
proto::literal
proto::logical_and
proto::logical_not
proto::logical_or
proto::make
proto::matches
proto::mem_ptr
proto::minus
proto::minus_assign
proto::modulus
proto::modulus_assign
proto::multiplies
proto::multiplies_assign
proto::nary_expr
proto::negate
proto::noinvoke
proto::not_
proto::not_equal_to
proto::nullary_expr
proto::or_
proto::otherwise
proto::pass_through
proto::plus
proto::plus_assign
proto::pod_generator
proto::post_dec
proto::post_inc
proto::pre_dec
proto::pre_inc
proto::protect
proto::result_of::as_child
proto::result_of::as_expr
proto::result_of::child
proto::result_of::child_c
proto::result_of::deep_copy
proto::result_of::eval
proto::result_of::flatten
proto::result_of::left
proto::result_of::make_expr
proto::result_of::right
proto::result_of::unpack_expr
proto::result_of::value
proto::reverse_fold
proto::reverse_fold_tree
proto::shift_left
proto::shift_left_assign
proto::shift_right
proto::shift_right_assign
proto::subscript
proto::switch_
proto::tag::address_of
proto::tag::assign
proto::tag::bitwise_and
proto::tag::bitwise_and_assign
proto::tag::bitwise_or
proto::tag::bitwise_or_assign
proto::tag::bitwise_xor
proto::tag::bitwise_xor_assign
proto::tag::comma
proto::tag::complement
proto::tag::dereference
proto::tag::divides
proto::tag::divides_assign
proto::tag::equal_to
proto::tag::function
proto::tag::greater
proto::tag::greater_equal
proto::tag::if_else_
proto::tag::less
proto::tag::less_equal
proto::tag::logical_and
proto::tag::logical_not
proto::tag::logical_or
proto::tag::mem_ptr
proto::tag::minus
proto::tag::minus_assign
proto::tag::modulus
proto::tag::modulus_assign
proto::tag::multiplies
proto::tag::multiplies_assign
proto::tag::negate
proto::tag::not_equal_to
proto::tag::plus
proto::tag::plus_assign
proto::tag::post_dec
proto::tag::post_inc
proto::tag::pre_dec
proto::tag::pre_inc
proto::tag::shift_left
proto::tag::shift_left_assign
proto::tag::shift_right
proto::tag::shift_right_assign
proto::tag::subscript
proto::tag::terminal
proto::tag::unary_plus
proto::tag_of
proto::term
proto::terminal
proto::transform
proto::transform_impl
proto::unary_expr
proto::unary_plus
proto::unexpr
proto::vararg
proto::when
proto::as_child()
proto::as_expr()
proto::assert_matches()
proto::assert_matches_not()
proto::child()
proto::child_c()
proto::deep_copy()
proto::display_expr()
proto::eval()
proto::flatten()
proto::if_else()
proto::left()
proto::lit()
proto::make_expr()
proto::right()
proto::unpack_expr()
proto::value()
Contains definitions of the
proto::term<>
,
proto::list1<>
,
proto::list2<>
, etc.
class templates.
namespace boost { namespace proto { template<typename T> struct term; template<typename... Arg> struct listN; } }
Includes all of Proto, except the contexts, transforms, debug utilities and Boost.Typeof registrations.
Utilities for debugging Proto expression trees
BOOST_PROTO_ASSERT_MATCHES(expr, Grammar) BOOST_PROTO_ASSERT_MATCHES_NOT(expr, Grammar)
namespace boost { namespace proto { template<typename Expr> void display_expr(Expr const &, std::ostream &); template<typename Expr> void display_expr(Expr const &); template<typename Grammar, typename Expr> void assert_matches(Expr const &); template<typename Grammar, typename Expr> void assert_matches_not(Expr const &); namespace functional { struct display_expr; } } }
Replace all nodes stored by reference by nodes stored by value.
namespace boost { namespace proto { template<typename Expr> typename proto::result_of::deep_copy<Expr>::type deep_copy(Expr const &); namespace result_of { template<typename Expr> struct deep_copy; } namespace functional { struct deep_copy; } } }
Contains definition of proto::domain<>
class template and helpers for defining domains with a generator and a grammar for controlling
operator overloading.
namespace boost { namespace proto { template<typename Generator = proto::default_generator, typename Grammar = proto::_> struct domain; struct default_domain; struct deduce_domain; template<typename T> struct is_domain; template<typename T> struct domain_of; } }
Contains the
proto::eval()
expression evaluator.
namespace boost { namespace proto { template<typename Expr, typename Context> typename proto::result_of::eval< Expr, Context >::type eval(Expr &, Context &); template<typename Expr, typename Context> typename proto::result_of::eval< Expr, Context >::type eval(Expr &, Context const &); namespace functional { struct eval; } namespace result_of { template<typename Expr, typename Context> struct eval; } } }
namespace boost { namespace proto { template<typename Tag, typename Args, long Arity = Args::arity> struct expr; template<typename Expr> struct unexpr; } }
Macros and a base class for defining end-user expression types
BOOST_PROTO_EXTENDS(Expr, Derived, Domain) BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain) BOOST_PROTO_EXTENDS_ASSIGN() BOOST_PROTO_EXTENDS_FUNCTION() BOOST_PROTO_EXTENDS_SUBSCRIPT() BOOST_PROTO_EXTENDS_USING_ASSIGN(Derived) BOOST_PROTO_EXTENDS_USING_ASSIGN_NON_DEPENDENT(Derived)
namespace boost { namespace proto { struct is_proto_expr; template<typename Expr, typename Derived, typename Domain = proto::default_domain> struct extends; } }
Make any Proto expression a valid Fusion sequence
namespace boost { namespace proto { template<typename Expr> typename proto::result_of::flatten< Expr >::type const flatten(Expr &); template<typename Expr> typename proto::result_of::flatten< Expr const >::type const flatten(Expr const &); namespace functional { struct flatten; struct pop_front; struct reverse; } namespace result_of { template<typename Expr> struct flatten; } } }
Contains definition of proto::generator<>
class template and friends that end users can use to generate domain-specific expression wrappers.
namespace boost { namespace proto { struct 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; } }
The
proto::literal<>
terminal wrapper, and the
proto::lit()
function for creating
proto::literal<>
wrappers.
namespace boost { namespace proto { template<typename T, typename Domain = proto::default_domain> struct literal; template<typename T> proto::literal< T & > const lit(T &); template<typename T> proto::literal< T const & > const lit(T const &); } }
Definition of the proto::make_expr()
and proto::unpack_expr()
utilities for building Proto expression nodes from child nodes or from a Fusion sequence of child
nodes, respectively.
namespace boost { namespace proto { template<typename Tag, typename... A> typename proto::result_of::make_expr<Tag, A const...>::type const make_expr(A const &...); template<typename Tag, typename Domain, typename... A> typename proto::result_of::make_expr<Tag, Domain, A const...>::type const make_expr(A const &...); template<typename Tag, typename Sequence> typename proto::result_of::unpack_expr<Tag, Sequence const>::type const unpack_expr(Sequence const &); template<typename Tag, typename Domain, typename Sequence> typename proto::result_of::unpack_expr<Tag, Domain, Sequence const>::type const unpack_expr(Sequence const &); namespace functional { template<typename Tag, typename Domain = proto::deduce_domain> struct make_expr; template<typename Tag, typename Domain = proto::deduce_domain> struct unpack_expr; } namespace result_of { template<typename Tag, typename... A> struct make_expr; template<typename Tag, typename Domain, typename... A> struct make_expr<Tag, Domain, A...>; template<typename Tag, typename Sequence, typename Void = void> struct unpack_expr; template<typename Tag, typename Domain, typename Sequence> struct unpack_expr<Tag, Domain, Sequence>; } } }
Contains definition of the
proto::matches<>
metafunction for determining if a given expression matches a given pattern.
namespace boost { namespace proto { struct _; template<typename Grammar> struct not_; template<typename If, typename Then = proto::_, typename Else = proto::not_<proto::_> > struct if_; template<typename... G> struct or_; template<typename... G> struct and_; template<typename Cases> struct switch_; template<typename T> struct exact; template<typename T> struct convertible_to; template<typename Grammar> struct vararg; template<typename Expr, typename Grammar> struct matches; } }
Contains all the overloaded operators that make it possible to build Proto expression trees.
BOOST_PROTO_DEFINE_OPERATORS(Trait, Domain)
namespace boost { namespace proto { template<typename T> struct is_extension; template<typename Arg> unspecified operator+(Arg & arg); template<typename Arg> unspecified operator+(Arg const & arg); template<typename Arg> unspecified operator-(Arg & arg); template<typename Arg> unspecified operator-(Arg const & arg); template<typename Arg> unspecified operator*(Arg & arg); template<typename Arg> unspecified operator*(Arg const & arg); template<typename Arg> unspecified operator~(Arg & arg); template<typename Arg> unspecified operator~(Arg const & arg); template<typename Arg> unspecified operator&(Arg & arg); template<typename Arg> unspecified operator&(Arg const & arg); template<typename Arg> unspecified operator!(Arg & arg); template<typename Arg> unspecified operator!(Arg const & arg); template<typename Arg> unspecified operator++(Arg & arg); template<typename Arg> unspecified operator++(Arg const & arg); template<typename Arg> unspecified operator--(Arg & arg); template<typename Arg> unspecified operator--(Arg const & arg); template<typename Arg> unspecified operator++(Arg & arg, int); template<typename Arg> unspecified operator++(Arg const & arg, int); template<typename Arg> unspecified operator--(Arg & arg, int); template<typename Arg> unspecified operator--(Arg const & arg, int); template<typename Left, typename Right> unspecified operator<<(Left & left, Right & right); template<typename Left, typename Right> unspecified operator<<(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator<<(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator<<(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator>>(Left & left, Right & right); template<typename Left, typename Right> unspecified operator>>(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator>>(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator>>(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator*(Left & left, Right & right); template<typename Left, typename Right> unspecified operator*(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator*(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator*(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator/(Left & left, Right & right); template<typename Left, typename Right> unspecified operator/(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator/(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator/(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator%(Left & left, Right & right); template<typename Left, typename Right> unspecified operator%(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator%(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator%(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator+(Left & left, Right & right); template<typename Left, typename Right> unspecified operator+(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator+(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator+(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator-(Left & left, Right & right); template<typename Left, typename Right> unspecified operator-(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator-(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator-(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator<(Left & left, Right & right); template<typename Left, typename Right> unspecified operator<(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator<(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator<(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator>(Left & left, Right & right); template<typename Left, typename Right> unspecified operator>(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator>(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator>(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator<=(Left & left, Right & right); template<typename Left, typename Right> unspecified operator<=(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator<=(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator<=(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator>=(Left & left, Right & right); template<typename Left, typename Right> unspecified operator>=(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator>=(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator>=(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator==(Left & left, Right & right); template<typename Left, typename Right> unspecified operator==(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator==(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator==(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator!=(Left & left, Right & right); template<typename Left, typename Right> unspecified operator!=(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator!=(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator!=(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator||(Left & left, Right & right); template<typename Left, typename Right> unspecified operator||(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator||(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator||(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator&&(Left & left, Right & right); template<typename Left, typename Right> unspecified operator&&(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator&&(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator&&(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator&(Left & left, Right & right); template<typename Left, typename Right> unspecified operator&(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator&(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator&(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator|(Left & left, Right & right); template<typename Left, typename Right> unspecified operator|(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator|(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator|(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator^(Left & left, Right & right); template<typename Left, typename Right> unspecified operator^(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator^(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator^(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator,(Left & left, Right & right); template<typename Left, typename Right> unspecified operator,(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator,(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator,(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator->*(Left & left, Right & right); template<typename Left, typename Right> unspecified operator->*(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator->*(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator->*(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator<<=(Left & left, Right & right); template<typename Left, typename Right> unspecified operator<<=(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator<<=(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator<<=(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator>>=(Left & left, Right & right); template<typename Left, typename Right> unspecified operator>>=(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator>>=(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator>>=(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator*=(Left & left, Right & right); template<typename Left, typename Right> unspecified operator*=(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator*=(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator*=(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator/=(Left & left, Right & right); template<typename Left, typename Right> unspecified operator/=(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator/=(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator/=(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator%=(Left & left, Right & right); template<typename Left, typename Right> unspecified operator%=(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator%=(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator%=(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator+=(Left & left, Right & right); template<typename Left, typename Right> unspecified operator+=(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator+=(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator+=(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator-=(Left & left, Right & right); template<typename Left, typename Right> unspecified operator-=(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator-=(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator-=(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator&=(Left & left, Right & right); template<typename Left, typename Right> unspecified operator&=(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator&=(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator&=(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator|=(Left & left, Right & right); template<typename Left, typename Right> unspecified operator|=(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator|=(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator|=(Left const & left, Right const & right); template<typename Left, typename Right> unspecified operator^=(Left & left, Right & right); template<typename Left, typename Right> unspecified operator^=(Left & left, Right const & right); template<typename Left, typename Right> unspecified operator^=(Left const & left, Right & right); template<typename Left, typename Right> unspecified operator^=(Left const & left, Right const & right); template<typename A0, typename A1, typename A2> typename proto::result_of::make_expr< proto::tag::if_else_, proto::deduce_domain, A0 const &, A1 const &, A2 const & >::type const if_else(A0 const & a0, A1 const & a1, A2 const & a2); namespace exops { BOOST_PROTO_DEFINE_OPERATORS (is_extension, default_domain); } } }
Includes all of Proto, except the Boost.Typeof registrations.
Forward declarations of all of proto's public types and functions.
BOOST_PROTO_MAX_ARITY BOOST_PROTO_MAX_LOGICAL_ARITY BOOST_PROTO_MAX_FUNCTION_CALL_ARITY
namespace boost { namespace proto { struct callable; int const N; typedef proto::functional::flatten _flatten; typedef proto::functional::pop_front _pop_front; typedef proto::functional::reverse _reverse; typedef proto::functional::eval _eval; typedef proto::functional::deep_copy _deep_copy; typedef proto::functional::make_expr< proto::tag::terminal > _make_terminal; typedef proto::functional::make_expr< proto::tag::unary_plus > _make_unary_plus; typedef proto::functional::make_expr< proto::tag::negate > _make_negate; typedef proto::functional::make_expr< proto::tag::dereference > _make_dereference; typedef proto::functional::make_expr< proto::tag::complement > _make_complement; typedef proto::functional::make_expr< proto::tag::address_of > _make_address_of; typedef proto::functional::make_expr< proto::tag::logical_not > _make_logical_not; typedef proto::functional::make_expr< proto::tag::pre_inc > _make_pre_inc; typedef proto::functional::make_expr< proto::tag::pre_dec > _make_pre_dec; typedef proto::functional::make_expr< proto::tag::post_inc > _make_post_inc; typedef proto::functional::make_expr< proto::tag::post_dec > _make_post_dec; typedef proto::functional::make_expr< proto::tag::shift_left > _make_shift_left; typedef proto::functional::make_expr< proto::tag::shift_right > _make_shift_right; typedef proto::functional::make_expr< proto::tag::multiplies > _make_multiplies; typedef proto::functional::make_expr< proto::tag::divides > _make_divides; typedef proto::functional::make_expr< proto::tag::modulus > _make_modulus; typedef proto::functional::make_expr< proto::tag::plus > _make_plus; typedef proto::functional::make_expr< proto::tag::minus > _make_minus; typedef proto::functional::make_expr< proto::tag::less > _make_less; typedef proto::functional::make_expr< proto::tag::greater > _make_greater; typedef proto::functional::make_expr< proto::tag::less_equal > _make_less_equal; typedef proto::functional::make_expr< proto::tag::greater_equal > _make_greater_equal; typedef proto::functional::make_expr< proto::tag::equal_to > _make_equal_to; typedef proto::functional::make_expr< proto::tag::not_equal_to > _make_not_equal_to; typedef proto::functional::make_expr< proto::tag::logical_or > _make_logical_or; typedef proto::functional::make_expr< proto::tag::logical_and > _make_logical_and; typedef proto::functional::make_expr< proto::tag::bitwise_and > _make_bitwise_and; typedef proto::functional::make_expr< proto::tag::bitwise_or > _make_bitwise_or; typedef proto::functional::make_expr< proto::tag::bitwise_xor > _make_bitwise_xor; typedef proto::functional::make_expr< proto::tag::comma > _make_comma; typedef proto::functional::make_expr< proto::tag::mem_ptr > _make_mem_ptr; typedef proto::functional::make_expr< proto::tag::assign > _make_assign; typedef proto::functional::make_expr< proto::tag::shift_left_assign > _make_shift_left_assign; typedef proto::functional::make_expr< proto::tag::shift_right_assign > _make_shift_right_assign; typedef proto::functional::make_expr< proto::tag::multiplies_assign > _make_multiplies_assign; typedef proto::functional::make_expr< proto::tag::divides_assign > _make_divides_assign; typedef proto::functional::make_expr< proto::tag::modulus_assign > _make_modulus_assign; typedef proto::functional::make_expr< proto::tag::plus_assign > _make_plus_assign; typedef proto::functional::make_expr< proto::tag::minus_assign > _make_minus_assign; typedef proto::functional::make_expr< proto::tag::bitwise_and_assign > _make_bitwise_and_assign; typedef proto::functional::make_expr< proto::tag::bitwise_or_assign > _make_bitwise_or_assign; typedef proto::functional::make_expr< proto::tag::bitwise_xor_assign > _make_bitwise_xor_assign; typedef proto::functional::make_expr< proto::tag::subscript > _make_subscript; typedef proto::functional::make_expr< proto::tag::if_else_ > _make_if_else; typedef proto::functional::make_expr< proto::tag::function > _make_function; typedef proto::_child_c<N
> _childN; // For eachN
in[0,BOOST_PROTO_MAX_ARITY)
typedef proto::_child0 _child; typedef proto::_child0 _left; typedef proto::_child1 _right; namespace functional { typedef proto::functional::make_expr< proto::tag::terminal > make_terminal; typedef proto::functional::make_expr< proto::tag::unary_plus > make_unary_plus; typedef proto::functional::make_expr< proto::tag::negate > make_negate; typedef proto::functional::make_expr< proto::tag::dereference > make_dereference; typedef proto::functional::make_expr< proto::tag::complement > make_complement; typedef proto::functional::make_expr< proto::tag::address_of > make_address_of; typedef proto::functional::make_expr< proto::tag::logical_not > make_logical_not; typedef proto::functional::make_expr< proto::tag::pre_inc > make_pre_inc; typedef proto::functional::make_expr< proto::tag::pre_dec > make_pre_dec; typedef proto::functional::make_expr< proto::tag::post_inc > make_post_inc; typedef proto::functional::make_expr< proto::tag::post_dec > make_post_dec; typedef proto::functional::make_expr< proto::tag::shift_left > make_shift_left; typedef proto::functional::make_expr< proto::tag::shift_right > make_shift_right; typedef proto::functional::make_expr< proto::tag::multiplies > make_multiplies; typedef proto::functional::make_expr< proto::tag::divides > make_divides; typedef proto::functional::make_expr< proto::tag::modulus > make_modulus; typedef proto::functional::make_expr< proto::tag::plus > make_plus; typedef proto::functional::make_expr< proto::tag::minus > make_minus; typedef proto::functional::make_expr< proto::tag::less > make_less; typedef proto::functional::make_expr< proto::tag::greater > make_greater; typedef proto::functional::make_expr< proto::tag::less_equal > make_less_equal; typedef proto::functional::make_expr< proto::tag::greater_equal > make_greater_equal; typedef proto::functional::make_expr< proto::tag::equal_to > make_equal_to; typedef proto::functional::make_expr< proto::tag::not_equal_to > make_not_equal_to; typedef proto::functional::make_expr< proto::tag::logical_or > make_logical_or; typedef proto::functional::make_expr< proto::tag::logical_and > make_logical_and; typedef proto::functional::make_expr< proto::tag::bitwise_and > make_bitwise_and; typedef proto::functional::make_expr< proto::tag::bitwise_or > make_bitwise_or; typedef proto::functional::make_expr< proto::tag::bitwise_xor > make_bitwise_xor; typedef proto::functional::make_expr< proto::tag::comma > make_comma; typedef proto::functional::make_expr< proto::tag::mem_ptr > make_mem_ptr; typedef proto::functional::make_expr< proto::tag::assign > make_assign; typedef proto::functional::make_expr< proto::tag::shift_left_assign > make_shift_left_assign; typedef proto::functional::make_expr< proto::tag::shift_right_assign > make_shift_right_assign; typedef proto::functional::make_expr< proto::tag::multiplies_assign > make_multiplies_assign; typedef proto::functional::make_expr< proto::tag::divides_assign > make_divides_assign; typedef proto::functional::make_expr< proto::tag::modulus_assign > make_modulus_assign; typedef proto::functional::make_expr< proto::tag::plus_assign > make_plus_assign; typedef proto::functional::make_expr< proto::tag::minus_assign > make_minus_assign; typedef proto::functional::make_expr< proto::tag::bitwise_and_assign > make_bitwise_and_assign; typedef proto::functional::make_expr< proto::tag::bitwise_or_assign > make_bitwise_or_assign; typedef proto::functional::make_expr< proto::tag::bitwise_xor_assign > make_bitwise_xor_assign; typedef proto::functional::make_expr< proto::tag::subscript > make_subscript; typedef proto::functional::make_expr< proto::tag::if_else_ > make_if_else; typedef proto::functional::make_expr< proto::tag::function > make_function; } } }
Boost.Typeof registrations for Proto's types, and definition of the
BOOST_PROTO_AUTO()
macro.
BOOST_PROTO_AUTO(Var, Expr)
Contains macros to ease the generation of repetitious code constructs.
BOOST_PROTO_REPEAT(MACRO) BOOST_PROTO_REPEAT_FROM_TO(FROM, TO, MACRO) BOOST_PROTO_REPEAT_EX(MACRO, typename_A, A, A_a, a) BOOST_PROTO_REPEAT_FROM_TO_EX(FROM, TO, MACRO, typename_A, A, A_a, a) BOOST_PROTO_LOCAL_ITERATE() BOOST_PROTO_typename_A(N) BOOST_PROTO_A_const_ref(N) BOOST_PROTO_A_ref(N) BOOST_PROTO_A(N) BOOST_PROTO_A_const(N) BOOST_PROTO_A_const_ref_a(N) BOOST_PROTO_A_ref_a(N) BOOST_PROTO_ref_a(N) BOOST_PROTO_a(N)
Contains the tags for all the overloadable operators in C++
namespace boost { namespace proto { 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 if_else_; struct function; } } }
Contains definitions for child<>, child_c<>, left<>, right<>, tag_of<>, and the helper functions child(), child_c(), value(), left() and right().
namespace boost { namespace proto { template<typename T> struct is_callable; template<typename T> struct is_aggregate; template<typename T> struct terminal; template<typename T, typename U, typename V> struct if_else_; 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... A> struct function; template<typename Tag, typename T> struct nullary_expr; template<typename Tag, typename T> struct unary_expr; template<typename Tag, typename T, typename U> struct binary_expr; template<typename Tag, typename... A> struct nary_expr; template<typename T> struct is_expr; template<typename Expr> struct tag_of; template<typename Expr> struct arity_of; template<typename T> typename proto::result_of::as_expr< T >::type as_expr(T &); template<typename T> typename proto::result_of::as_expr< T const >::type as_expr(T const &); template<typename Domain, typename T> typename proto::result_of::as_expr< T, Domain >::type as_expr(T &); template<typename Domain, typename T> typename proto::result_of::as_expr< T const, Domain >::type as_expr(T const &); template<typename T> typename proto::result_of::as_child< T >::type as_child(T &); template<typename T> typename proto::result_of::as_child< T const >::type as_child(T const &); template<typename Domain, typename T> typename proto::result_of::as_child< T, Domain >::type as_child(T &); template<typename Domain, typename T> typename proto::result_of::as_child< T const, Domain >::type as_child(T const &); template<typename N, typename Expr> typename proto::result_of::child< Expr &, N >::type child(Expr &); template<typename N, typename Expr> typename proto::result_of::child< Expr const &, N >::type child(Expr const &); template<typename Expr> typename proto::result_of::child< Expr & >::type child(Expr &); template<typename Expr> typename proto::result_of::child< Expr const & >::type child(Expr const &); template<long N, typename Expr> typename proto::result_of::child_c< Expr &, N >::type child_c(Expr &); template<long N, typename Expr> typename proto::result_of::child_c< Expr const &, N >::type child_c(Expr const &); template<typename Expr> typename proto::result_of::value< Expr & >::type value(Expr &); template<typename Expr> typename proto::result_of::value< Expr const & >::type value(Expr const &); template<typename Expr> typename proto::result_of::left< Expr & >::type left(Expr &); template<typename Expr> typename proto::result_of::left< Expr const & >::type left(Expr const &); template<typename Expr> typename proto::result_of::right< Expr & >::type right(Expr &); template<typename Expr> typename proto::result_of::right< Expr const & >::type right(Expr const &); namespace functional { template<typename Domain = proto::default_domain> struct as_expr; template<typename Domain = proto::default_domain> struct as_child; template<long N> struct child_c; template<typename N = mpl::long_<0> > struct child; struct value; struct left; struct right; } namespace result_of { template<typename T, typename Domain = proto::default_domain> struct as_expr; template<typename T, typename Domain = proto::default_domain> struct as_child; template<typename Expr, typename N = mpl::long_<0> > struct child; template<typename Expr> struct value; template<typename Expr> struct left; template<typename Expr> struct right; template<typename Expr, long N> struct child_c; } } }
Contains definition of the childN transforms and friends.
namespace boost { namespace proto { struct _expr; struct _state; struct _data; template<int N> struct _child_c; struct _value; struct _byref; struct _byval; } }
Contains definition of the call<> transform.
namespace boost { namespace proto { template<typename T> struct call; } }
namespace boost {
namespace proto {
template<typename Grammar = unspecified
> struct _default;
}
}
Contains definition of the
proto::fold<>
and
proto::reverse_fold<>
transforms.
namespace boost { namespace proto { template<typename Sequence, typename State0, typename Fun> struct fold; template<typename Sequence, typename State0, typename Fun> struct reverse_fold; } }
Contains definition of the
proto::fold_tree<>
and
proto::reverse_fold_tree<>
transforms.
namespace boost { namespace proto { template<typename Sequence, typename State0, typename Fun> struct fold_tree; template<typename Sequence, typename State0, typename Fun> struct reverse_fold_tree; } }
Contains definition of transform<> and transform_impl<> helpers.
namespace boost { namespace proto { template<typename PrimitiveTransform> struct transform; template<typename Expr, typename State, typename Data> struct transform_impl; } }
Contains definition of the
proto::lazy<>
transform.
namespace boost { namespace proto { template<typename T> struct lazy; } }
Contains definition of the
proto::make<>
and
proto::protect<>
transforms.
namespace boost { namespace proto { template<typename T> struct noinvoke; template<typename PrimitiveTransform> struct protect; template<typename T> struct make; } }
Definition of the
proto::pass_through<>
transform, which is the default transform of all of the expression generator metafunctions such as
proto::unary_plus<>
,
proto::plus<>
and
proto::nary_expr<>
.
namespace boost { namespace proto { template<typename Grammar> struct pass_through; } }
Definition of the
proto::when<>
and
proto::otherwise<>
transforms.
namespace boost { namespace proto { template<typename Grammar, typename PrimitiveTransform = Grammar> struct when; template<typename Grammar, typename Fun> struct when<Grammar, Fun *>; template<typename Grammar, typename R, typename... A> struct when<Grammar, R(A...)>; template<typename Fun> struct otherwise; } }
Definintion of proto::context::callable_context<>
,
an evaluation context for proto::eval()
that fans out 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.
namespace boost { namespace proto { namespace context { template<typename Expr, typename Context> struct callable_eval; template<typename Context, typename DefaultCtx = proto::context::default_context> struct callable_context; } } }
namespace boost { namespace proto { namespace context { template<typename Expr, typename Context> struct default_eval; struct default_context; } } }
Definintion of
proto::context::null_context<>
,
an evaluation context for
proto::eval()
that simply evaluates each child expression, doesn't combine the results at all, and returns void.
namespace boost { namespace proto { namespace context { template<typename Expr, typename Context> struct null_eval; struct null_context; } } }