|  | Home | Libraries | People | FAQ | More | 
          proto::_
        
          proto::_byref
        
          proto::_byval
        
          proto::_child_c
        
          proto::_data
        
          proto::_default
        
          proto::_env
        
          proto::_env_var
        
          proto::_expr
        
          proto::_state
        
          proto::_value
        
          proto::_void
        
          proto::address_of
        
          proto::and_
        
          proto::arity_of
        
          proto::assign
        
          proto::basic_default_domain
        
          proto::basic_default_generator
        
          proto::basic_expr
        
          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::char_
        
          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::data_type
        
          proto::deduce_domain
        
          proto::default_domain
        
          proto::default_generator
        
          proto::dereference
        
          proto::divides
        
          proto::divides_assign
        
          proto::domain
        
          proto::domain::as_child
        
          proto::domain::as_expr
        
          proto::domain_of
        
          proto::empty_env
        
          proto::env
        
          proto::equal_to
        
          proto::exact
        
          proto::expr
        
          proto::extends
        
          proto::external_transform
        
          proto::external_transforms
        
          proto::fold
        
          proto::fold_tree
        
          proto::function
        
          proto::functional::advance
        
          proto::functional::as_child
        
          proto::functional::as_env
        
          proto::functional::as_expr
        
          proto::functional::at
        
          proto::functional::begin
        
          proto::functional::child
        
          proto::functional::child_c
        
          proto::functional::deep_copy
        
          proto::functional::display_expr
        
          proto::functional::distance
        
          proto::functional::empty
        
          proto::functional::end
        
          proto::functional::env_var
        
          proto::functional::eval
        
          proto::functional::first
        
          proto::functional::flatten
        
          proto::functional::has_env_var
        
          proto::functional::left
        
          proto::functional::make_expr
        
          proto::functional::make_pair
        
          proto::functional::next
        
          proto::functional::pop_back
        
          proto::functional::pop_front
        
          proto::functional::prior
        
          proto::functional::push_back
        
          proto::functional::push_front
        
          proto::functional::rbegin
        
          proto::functional::rend
        
          proto::functional::reverse
        
          proto::functional::right
        
          proto::functional::second
        
          proto::functional::size
        
          proto::functional::unpack_expr
        
          proto::functional::value
        
          proto::generator
        
          proto::greater
        
          proto::greater_equal
        
          proto::if_
        
          proto::if_else_
        
          proto::int_
        
          proto::integral_c
        
          proto::is_aggregate
        
          proto::is_callable
        
          proto::is_domain
        
          proto::is_env
        
          proto::is_expr
        
          proto::is_extension
        
          proto::is_proto_expr
        
          proto::is_transform
        
          proto::key_not_found
        
          proto::lazy
        
          proto::less
        
          proto::less_equal
        
          proto::list1<>, proto::list2<>, ...
        
          proto::literal
        
          proto::logical_and
        
          proto::logical_not
        
          proto::logical_or
        
          proto::long_
        
          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::pack
        
          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_env
        
          proto::result_of::as_expr
        
          proto::result_of::child
        
          proto::result_of::child_c
        
          proto::result_of::deep_copy
        
          proto::result_of::env_var
        
          proto::result_of::eval
        
          proto::result_of::flatten
        
          proto::result_of::has_env_var
        
          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::size_t
        
          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::transforms_type
        
          proto::transform_impl
        
          proto::unary_expr
        
          proto::unary_plus
        
          proto::use_basic_expr
        
          proto::unexpr
        
          proto::vararg
        
          proto::wants_basic_expr
        
          proto::when
        
          proto::as_child()
        
          proto::as_env()
        
          proto::as_expr()
        
          proto::assert_matches()
        
          proto::assert_matches_not()
        
          proto::child()
        
          proto::child_c()
        
          proto::deep_copy()
        
          proto::display_expr()
        
          proto::env_var()
        
          proto::eval()
        
          proto::flatten()
        
          proto::has_env_var()
        
          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 the proto::domain<>
     class template and helpers for defining domains with a generator for customizing expression
    construction and a grammar for controlling operator overloading.
  
namespace boost {
  namespace proto {
    template<typename Generator = proto::default_generator, 
             typename Grammar = proto::_, typename Super = unspecified> 
      struct domain;
    struct default_domain;
    struct basic_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 basic_expr; 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; } }
Includes all the functional extensions of Proto.
Includes all the functional extensions to Proto for the Boost.Fusion library.
Includes Proto callable boost::proto::functional::at.
namespace boost { namespace proto { namespace functional { struct at; } } }
Includes Proto callable boost::proto::functional::pop_back.
namespace boost { namespace proto { namespace functional { struct pop_back; } } }
Includes Proto callable boost::proto::functional::pop_front.
namespace boost { namespace proto { namespace functional { struct pop_front; } } }
Includes Proto callable boost::proto::functional::push_back.
namespace boost { namespace proto { namespace functional { struct push_back; } } }
Includes Proto callable boost::proto::functional::push_front.
namespace boost { namespace proto { namespace functional { struct push_front; } } }
Includes Proto callable boost::proto::functional::reverse.
namespace boost { namespace proto { namespace functional { struct reverse; } } }
Includes Proto callable boost::proto::functional::begin.
namespace boost { namespace proto { namespace functional { struct begin; } } }
Includes Proto callable boost::proto::functional::empty.
namespace boost { namespace proto { namespace functional { struct empty; } } }
Includes Proto callable boost::proto::functional::end.
namespace boost { namespace proto { namespace functional { struct end; } } }
Includes Proto callable boost::proto::functional::rbegin.
namespace boost { namespace proto { namespace functional { struct rbegin; } } }
Includes Proto callable boost::proto::functional::rend.
namespace boost { namespace proto { namespace functional { struct rend; } } }
Includes Proto callable boost::proto::functional::size.
namespace boost { namespace proto { namespace functional { struct size; } } }
Includes all the functional extensions to Proto for the standard library.
Includes Proto callables for the functions found in the standard <iterator> header.
namespace boost { namespace proto { namespace functional { struct advance; struct distance; struct next; struct prior; } } }
Defines Proto callables boost::proto::functional::make_pair,
  boost::proto::functional::first and
  boost::proto::functional::second.
namespace boost { namespace proto { namespace functional { struct make_pair; struct first; struct second; } } }
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; } namespace result_of { template<typename Expr> struct flatten; } } }
Contains definition of
    proto::default_generator,
    proto::generator<>,
    proto::pod_generator<>
    and other utilities that users can use to post-process new expression objects that
    Proto creates.
namespace boost { namespace proto { 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> struct use_basic_expr; template<typename Generator> struct wants_basic_expr; } }
    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, typename Transform> 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); } }
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::make_pair _make_pair; typedef proto::functional::first _first; typedef proto::functional::second _second; typedef proto::functional::pop_back _pop_back; typedef proto::functional::pop_front _pop_front; typedef proto::functional::push_back _push_back; typedef proto::functional::push_front _push_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 eachNin[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 various expression traits and utilities like
    proto::tag_of<> and
    proto::arity_of<>;
    the functions
    proto::value(),
    proto::left() and
    proto::right();
    proto::child(),
    proto::child_c(),
    proto::as_expr(),
    proto::as_child(),
    and assorted helpers.
  
namespace boost { namespace proto { template<typename T> struct is_callable; template<typename T> struct is_transform; 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; } } }
Includes all the built-in transforms of Proto.
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 _void; 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;
  }
}
BOOST_PROTO_DEFINE_ENV_VAR(Type, Name)
namespace boost { namespace proto { struct key_not_found; struct empty_env; template<typename Key, typename Value, typename Env = proto::empty_env> struct env; template<typename T> struct is_env; struct data_type; proto::data_type const data; template<typename Key> struct _env_var; struct _env; template<typename T> typename proto::result_of::as_env<T &>::type as_env(T &); template<typename T> typename proto::result_of::as_env<T const &>::type as_env(T const &); template<typename Key, typename Env> typename proto::result_of::has_env_var<Env &, Key>::type has_env_var(Env &); template<typename Key, typename Env> typename proto::result_of::has_env_var<Env const &, Key>::type has_env_var(Env const &); template<typename Key, typename Env> typename proto::result_of::env_var<Env &, Key>::type env_var(Env &); template<typename Key, typename Env> typename proto::result_of::env_var<Env const &, Key>::type env_var(Env const &); template<typename Env, typename Key, typename Value> proto::env<Key, Value,UNCVREF(typename proto::result_of::as_env<Env &>::type)> operator,(Env &, proto::env<Key, Value> const &); template<typename Env, typename Key, typename Value> proto::env<Key, Value,UNCVREF(typename proto::result_of::as_env<Env const &>::type)> operator,(Env const &, proto::env<Key, Value> const &); namespace functional { struct as_env; template<typename Key> struct has_env_var; template<typename Key> struct env_var; } namespace result_of { template<typename T> struct as_env; template<typename Env, typename Key> struct has_env_var; template<typename Env, typename Key> struct env_var; } } }
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; struct pack; } }
Contains definition of the integral_c transform and friends.
namespace boost { namespace proto { 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; } }
    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, typename Domain = proto::deduce_domain> struct pass_through; } }
    Definition of the
    
      proto::when<>
     and
    
      proto::otherwise<>
     transforms.
  
namespace boost { namespace proto { struct transforms_type; proto::transforms_type const transforms; 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 Grammar, typename R, typename... A> struct when<Grammar, R(A..., ...)>; template<typename Grammar> struct when<Grammar, proto::external_transform>; template<typename Fun> struct otherwise; struct external_transform; template<typename... When> struct external_transforms; } }
Includes all the built-in evaluation contexts of Proto.
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; } } }