Macros and a base class for defining end-user expression types Empty type to be used as a dummy template parameter of POD expression wrappers. It allows argument-dependent lookup to find Proto's operator overloads. proto::is_proto_expr allows argument-dependent lookup to find Proto's operator overloads. For example: template<typename T, typename Dummy = proto::is_proto_expr> struct my_terminal { BOOST_PROTO_BASIC_EXTENDS( typename proto::terminal<T>::type , my_terminal<T> , proto::default_domain ) }; // ... my_terminal<int> _1, _2; _1 + _2; // OK, uses proto::operator+ Without the second Dummy template parameter, Proto's operator overloads would not be considered by name lookup. For adding behaviors to a Proto expression template. unspecified Expr typename Expr::proto_base_expr Domain Derived typename proto_base_expr::proto_tag typename proto_base_expr::proto_args typename proto_base_expr::proto_arity For each N in [0,max(1,proto_arity::value)) typename proto_base_expr::proto_childN extends const & Expr const & static Derived const Expr const & proto_base_expr & proto_expr_.proto_base() Will not throw. proto_base_expr const & proto_expr_.proto_base() Will not throw. unspecified A & Lazy assignment expression A new expression node representing the assignment operation. unspecified A const & This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. unspecified A & This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. unspecified A const & This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. unspecified A & Lazy subscript expression A new expression node representing the subscript operation. unspecified A const & This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. unspecified A & This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. unspecified A const & This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. unspecified A const & Lazy function call A new expression node representing the function call operation. unspecified A const & This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. For creating expression wrappers that add members to a Proto expression template, like proto::extends<>, but while retaining POD-ness of the expression wrapper. BOOST_PROTO_BASIC_EXTENDS() adds the basic typedefs, member functions, and data members necessary to make a struct a valid Proto expression extension. It does not add any constructors, virtual functions or access control blocks that would render the containing struct non-POD. Expr is the Proto expression that the enclosing struct extends. Derived is the type of the enclosing struct. Domain is the Proto domain to which this expression extension belongs. (See proto::domain<>.) BOOST_PROTO_BASIC_EXTENDS() adds to its enclosing struct exactly one data member of type Expr. Example:template< class Expr > struct my_expr; struct my_domain : proto::domain< proto::pod_generator< my_expr > > {}; template< class Expr > struct my_expr { // OK, this makes my_expr<> a valid Proto expression extension. // my_expr<> does /not/ have overloaded assignment, subscript, // and function call operators that build expression templates, however. BOOST_PROTO_BASIC_EXTENDS(Expr, my_expr, my_domain) }; // OK, my_expr<> is POD, so this is statically initialized: my_expr< proto::terminal<int>::type > const _1 = {{1}}; See also: BOOST_PROTO_EXTENDS_ASSIGN() BOOST_PROTO_EXTENDS_SUBSCRIPT() BOOST_PROTO_EXTENDS_FUNCTION() BOOST_PROTO_EXTENDS() For adding to an expression extension class an overloaded assignment operator that builds an expression template. Use BOOST_PROTO_EXTENDS_ASSIGN() after BOOST_PROTO_BASIC_EXTENDS() to give an expression extension class an overloaded assignment operator that builds an expression template. See also: BOOST_PROTO_BASIC_EXTENDS() BOOST_PROTO_EXTENDS_SUBSCRIPT() BOOST_PROTO_EXTENDS_FUNCTION() BOOST_PROTO_EXTENDS() For adding to an expression extension class an overloaded subscript operator that builds an expression template. Use BOOST_PROTO_EXTENDS_SUBSCRIPT() after BOOST_PROTO_BASIC_EXTENDS() to give an expression extension class an overloaded subscript operator that builds an expression template. See also: BOOST_PROTO_BASIC_EXTENDS() BOOST_PROTO_EXTENDS_ASSIGN() BOOST_PROTO_EXTENDS_FUNCTION() BOOST_PROTO_EXTENDS() For adding to an expression extension class a set of overloaded function call operators that build expression templates. Use BOOST_PROTO_EXTENDS_FUNCTION() after BOOST_PROTO_BASIC_EXTENDS() to give an expression extension class a set of overloaded function call operators that build expression templates. In addition, BOOST_PROTO_EXTENDS_FUNCTION() adds a nested result<> class template that is a metafunction for calculating the return type of the overloaded function call operators. See also: BOOST_PROTO_BASIC_EXTENDS() BOOST_PROTO_EXTENDS_ASSIGN() BOOST_PROTO_EXTENDS_SUBSCRIPT() BOOST_PROTO_EXTENDS() For creating expression wrappers that add behaviors to a Proto expression template, like proto::extends<>, but while retaining POD-ness of the expression wrapper. Equivalent to: BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain) BOOST_PROTO_EXTENDS_ASSIGN() BOOST_PROTO_EXTENDS_SUBSCRIPT() BOOST_PROTO_EXTENDS_FUNCTION() Example:template< class Expr > struct my_expr; struct my_domain : proto::domain< proto::pod_generator< my_expr > > {}; template< class Expr > struct my_expr { // OK, this makes my_expr<> a valid Proto expression extension. // my_expr<> has overloaded assignment, subscript, // and function call operators that build expression templates. BOOST_PROTO_EXTENDS(Expr, my_expr, my_domain) }; // OK, my_expr<> is POD, so this is statically initialized: my_expr< proto::terminal<int>::type > const _1 = {{1}};