Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

Reference

Concepts
Classes
Functions
Header <boost/proto/args.hpp>
Header <boost/proto/core.hpp>
Header <boost/proto/debug.hpp>
Header <boost/proto/deep_copy.hpp>
Header <boost/proto/domain.hpp>
Header <boost/proto/eval.hpp>
Header <boost/proto/expr.hpp>
Header <boost/proto/extends.hpp>
Header <boost/proto/functional.hpp>
Header <boost/proto/functional/fusion.hpp>
Header <boost/proto/functional/fusion/at.hpp>
Header <boost/proto/functional/fusion/pop_back.hpp>
Header <boost/proto/functional/fusion/pop_front.hpp>
Header <boost/proto/functional/fusion/push_back.hpp>
Header <boost/proto/functional/fusion/push_front.hpp>
Header <boost/proto/functional/fusion/reverse.hpp>
Header <boost/proto/functional/range/begin.hpp>
Header <boost/proto/functional/range/empty.hpp>
Header <boost/proto/functional/range/end.hpp>
Header <boost/proto/functional/range/rbegin.hpp>
Header <boost/proto/functional/range/rend.hpp>
Header <boost/proto/functional/range/size.hpp>
Header <boost/proto/functional/std.hpp>
Header <boost/proto/functional/std/iterator.hpp>
Header <boost/proto/functional/std/utility.hpp>
Header <boost/proto/fusion.hpp>
Header <boost/proto/generate.hpp>
Header <boost/proto/literal.hpp>
Header <boost/proto/make_expr.hpp>
Header <boost/proto/matches.hpp>
Header <boost/proto/operators.hpp>
Header <boost/proto/proto.hpp>
Header <boost/proto/proto_fwd.hpp>
Header <boost/proto/proto_typeof.hpp>
Header <boost/proto/repeat.hpp>
Header <boost/proto/tags.hpp>
Header <boost/proto/traits.hpp>
Header <boost/proto/transform.hpp>
Header <boost/proto/transform/arg.hpp>
Header <boost/proto/transform/call.hpp>
Header <boost/proto/transform/default.hpp>
Header <boost/proto/transform/env.hpp>
Header <boost/proto/transform/fold.hpp>
Header <boost/proto/transform/fold_tree.hpp>
Header <boost/proto/transform/impl.hpp>
Header <boost/proto/transform/integral_c.hpp>
Header <boost/proto/transform/lazy.hpp>
Header <boost/proto/transform/make.hpp>
Header <boost/proto/transform/pass_through.hpp>
Header <boost/proto/transform/when.hpp>
Header <boost/proto/context.hpp>
Header <boost/proto/context/callable.hpp>
Header <boost/proto/context/default.hpp>
Header <boost/proto/context/null.hpp>

Concepts

Classes

Functions

Contains definitions of the proto::term<>, proto::list1<>, proto::list2<>, etc. class templates.


  
    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)

  
    template<typename Expr>  (, );
    template<typename Expr>  ();
    template<typename Grammar, typename Expr> 
       ();
    template<typename Grammar, typename Expr> 
       ();
    
      struct display_expr;
    }
  }
}

Replace all nodes stored by reference by nodes stored by value.


  
    template<typename Expr> 
      proto::result_of::deep_copy< ();
    
      template<typename Expr> struct deep_copy;
    }
    
      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.


  
    template<typename Generator = proto::default_generator, 
             typename Grammar = proto::_, typename Super> 
      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.


  
    template<typename Expr, typename Context> 
      proto::result_of::eval<  
      (, );
    template<typename Expr, typename Context> 
      proto::result_of::eval<  
      (, );
    
      struct eval;
    }
    
      template<typename Expr, typename Context> struct eval;
    }
  }
}

  
    template<typename Tag, typename Args,  Arity = > struct basic_expr;
    template<typename Tag, typename 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)

  
    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.


  
    
      struct at;
    }
  }
}

Includes Proto callable boost::proto::functional::pop_back.


  
    
      struct pop_back;
    }
  }
}

Includes Proto callable boost::proto::functional::pop_front.


  
    
      struct pop_front;
    }
  }
}

Includes Proto callable boost::proto::functional::push_back.


  
    
      struct push_back;
    }
  }
}

Includes Proto callable boost::proto::functional::push_front.


  
    
      struct push_front;
    }
  }
}

Includes Proto callable boost::proto::functional::reverse.


  
    
      struct reverse;
    }
  }
}

Includes Proto callable boost::proto::functional::begin.


  
    
      struct begin;
    }
  }
}

Includes Proto callable boost::proto::functional::empty.


  
    
      struct empty;
    }
  }
}

Includes Proto callable boost::proto::functional::end.


  
    
      struct end;
    }
  }
}

Includes Proto callable boost::proto::functional::rbegin.


  
    
      struct rbegin;
    }
  }
}

Includes Proto callable boost::proto::functional::rend.


  
    
      struct rend;
    }
  }
}

Includes Proto callable boost::proto::functional::size.


  
    
      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.


  
    
      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.


  
    
      struct make_pair;
      struct first;
      struct second;
    }
  }
}

Make any Proto expression a valid Fusion sequence


  
    template<typename Expr> 
      proto::result_of::flatten<  ();
    template<typename Expr> 
      proto::result_of::flatten<  
      ();
    
      struct flatten;
    }
    
      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.


  
    struct default_generator;
    struct basic_default_generator;
    template< Extends> struct generator;
    template< 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.


  
    template<typename T, typename Domain = proto::default_domain> 
      struct literal;
    template<typename T> proto::literal<  ();
    template<typename T> proto::literal<  ();
  }
}

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.


  
    template<typename Tag, typename... A> 
      proto::result_of::make_expr< 
      (...);
    template<typename Tag, typename Domain, typename... A> 
      proto::result_of::make_expr< 
      (...);
    template<typename Tag, typename Sequence> 
      proto::result_of::unpack_expr< 
      ();
    template<typename Tag, typename Domain, typename Sequence> 
      proto::result_of::unpack_expr< 
      ();
    
      template<typename Tag, typename Domain = proto::deduce_domain> 
        struct make_expr;
      template<typename Tag, typename Domain = proto::deduce_domain> 
        struct unpack_expr;
    }
    
      template<typename Tag, typename... A> struct make_expr;

      template<typename Tag, typename Domain, typename... A> 
        struct make_expr<, , ...>;

      template<typename Tag, typename Sequence, typename Void> struct unpack_expr;

      template<typename Tag, typename Domain, typename Sequence> 
        struct unpack_expr<, , >;
    }
  }
}

Contains definition of the proto::matches<> metafunction for determining if a given expression matches a given pattern.


  
    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)

  
    template<typename T> struct is_extension;
    template<typename Arg>  ( arg);
    template<typename Arg>  ( arg);
    template<typename Arg>  ( arg);
    template<typename Arg>  ( arg);
    template<typename Arg>  ( arg);
    template<typename Arg>  ( arg);
    template<typename Arg>  ( arg);
    template<typename Arg>  ( arg);
    template<typename Arg>  ( arg);
    template<typename Arg>  ( arg);
    template<typename Arg>  ( arg);
    template<typename Arg>  ( arg);
    template<typename Arg>  ( arg);
    template<typename Arg>  ( arg);
    template<typename Arg>  ( arg);
    template<typename Arg>  ( arg);
    template<typename Arg>  ( arg, );
    template<typename Arg>  ( arg, );
    template<typename Arg>  ( arg, );
    template<typename Arg>  ( arg, );
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename Left, typename Right> 
       ( left,  right);
    template<typename A0, typename A1, typename A2> 
      proto::result_of::make_expr<
        proto::tag::if_else_, 
        proto::deduce_domain,
         
      ( a0,  a1,  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

  
    struct callable;

     N;

    typedef proto::functional::flatten ;
    typedef proto::functional::make_pair ;
    typedef proto::functional::first ;
    typedef proto::functional::second ;
    typedef proto::functional::pop_back ;
    typedef proto::functional::pop_front ;
    typedef proto::functional::push_back ;
    typedef proto::functional::push_front ;
    typedef proto::functional::reverse ;
    typedef proto::functional::eval ;
    typedef proto::functional::deep_copy ;
    typedef proto::functional::make_expr< proto::tag::terminal > ;
    typedef proto::functional::make_expr< proto::tag::unary_plus > ;
    typedef proto::functional::make_expr< proto::tag::negate > ;
    typedef proto::functional::make_expr< proto::tag::dereference > ;
    typedef proto::functional::make_expr< proto::tag::complement > ;
    typedef proto::functional::make_expr< proto::tag::address_of > ;
    typedef proto::functional::make_expr< proto::tag::logical_not > ;
    typedef proto::functional::make_expr< proto::tag::pre_inc > ;
    typedef proto::functional::make_expr< proto::tag::pre_dec > ;
    typedef proto::functional::make_expr< proto::tag::post_inc > ;
    typedef proto::functional::make_expr< proto::tag::post_dec > ;
    typedef proto::functional::make_expr< proto::tag::shift_left > ;
    typedef proto::functional::make_expr< proto::tag::shift_right > ;
    typedef proto::functional::make_expr< proto::tag::multiplies > ;
    typedef proto::functional::make_expr< proto::tag::divides > ;
    typedef proto::functional::make_expr< proto::tag::modulus > ;
    typedef proto::functional::make_expr< proto::tag::plus > ;
    typedef proto::functional::make_expr< proto::tag::minus > ;
    typedef proto::functional::make_expr< proto::tag::less > ;
    typedef proto::functional::make_expr< proto::tag::greater > ;
    typedef proto::functional::make_expr< proto::tag::less_equal > ;
    typedef proto::functional::make_expr< proto::tag::greater_equal > ;
    typedef proto::functional::make_expr< proto::tag::equal_to > ;
    typedef proto::functional::make_expr< proto::tag::not_equal_to > ;
    typedef proto::functional::make_expr< proto::tag::logical_or > ;
    typedef proto::functional::make_expr< proto::tag::logical_and > ;
    typedef proto::functional::make_expr< proto::tag::bitwise_and > ;
    typedef proto::functional::make_expr< proto::tag::bitwise_or > ;
    typedef proto::functional::make_expr< proto::tag::bitwise_xor > ;
    typedef proto::functional::make_expr< proto::tag::comma > ;
    typedef proto::functional::make_expr< proto::tag::mem_ptr > ;
    typedef proto::functional::make_expr< proto::tag::assign > ;
    typedef proto::functional::make_expr< proto::tag::shift_left_assign > ;
    typedef proto::functional::make_expr< proto::tag::shift_right_assign > ;
    typedef proto::functional::make_expr< proto::tag::multiplies_assign > ;
    typedef proto::functional::make_expr< proto::tag::divides_assign > ;
    typedef proto::functional::make_expr< proto::tag::modulus_assign > ;
    typedef proto::functional::make_expr< proto::tag::plus_assign > ;
    typedef proto::functional::make_expr< proto::tag::minus_assign > ;
    typedef proto::functional::make_expr< proto::tag::bitwise_and_assign > ;
    typedef proto::functional::make_expr< proto::tag::bitwise_or_assign > ;
    typedef proto::functional::make_expr< proto::tag::bitwise_xor_assign > ;
    typedef proto::functional::make_expr< proto::tag::subscript > ;
    typedef proto::functional::make_expr< proto::tag::if_else_ > ;
    typedef proto::functional::make_expr< proto::tag::function > ;
    typedef proto::_child_c<  > ;  // For each N in [0,BOOST_PROTO_MAX_ARITY)
    typedef proto::_child0 ;
    typedef proto::_child0 ;
    typedef proto::_child1 ;
    
      typedef proto::functional::make_expr< proto::tag::terminal > ;
      typedef proto::functional::make_expr< proto::tag::unary_plus > ;
      typedef proto::functional::make_expr< proto::tag::negate > ;
      typedef proto::functional::make_expr< proto::tag::dereference > ;
      typedef proto::functional::make_expr< proto::tag::complement > ;
      typedef proto::functional::make_expr< proto::tag::address_of > ;
      typedef proto::functional::make_expr< proto::tag::logical_not > ;
      typedef proto::functional::make_expr< proto::tag::pre_inc > ;
      typedef proto::functional::make_expr< proto::tag::pre_dec > ;
      typedef proto::functional::make_expr< proto::tag::post_inc > ;
      typedef proto::functional::make_expr< proto::tag::post_dec > ;
      typedef proto::functional::make_expr< proto::tag::shift_left > ;
      typedef proto::functional::make_expr< proto::tag::shift_right > ;
      typedef proto::functional::make_expr< proto::tag::multiplies > ;
      typedef proto::functional::make_expr< proto::tag::divides > ;
      typedef proto::functional::make_expr< proto::tag::modulus > ;
      typedef proto::functional::make_expr< proto::tag::plus > ;
      typedef proto::functional::make_expr< proto::tag::minus > ;
      typedef proto::functional::make_expr< proto::tag::less > ;
      typedef proto::functional::make_expr< proto::tag::greater > ;
      typedef proto::functional::make_expr< proto::tag::less_equal > ;
      typedef proto::functional::make_expr< proto::tag::greater_equal > ;
      typedef proto::functional::make_expr< proto::tag::equal_to > ;
      typedef proto::functional::make_expr< proto::tag::not_equal_to > ;
      typedef proto::functional::make_expr< proto::tag::logical_or > ;
      typedef proto::functional::make_expr< proto::tag::logical_and > ;
      typedef proto::functional::make_expr< proto::tag::bitwise_and > ;
      typedef proto::functional::make_expr< proto::tag::bitwise_or > ;
      typedef proto::functional::make_expr< proto::tag::bitwise_xor > ;
      typedef proto::functional::make_expr< proto::tag::comma > ;
      typedef proto::functional::make_expr< proto::tag::mem_ptr > ;
      typedef proto::functional::make_expr< proto::tag::assign > ;
      typedef proto::functional::make_expr< proto::tag::shift_left_assign > ;
      typedef proto::functional::make_expr< proto::tag::shift_right_assign > ;
      typedef proto::functional::make_expr< proto::tag::multiplies_assign > ;
      typedef proto::functional::make_expr< proto::tag::divides_assign > ;
      typedef proto::functional::make_expr< proto::tag::modulus_assign > ;
      typedef proto::functional::make_expr< proto::tag::plus_assign > ;
      typedef proto::functional::make_expr< proto::tag::minus_assign > ;
      typedef proto::functional::make_expr< proto::tag::bitwise_and_assign > ;
      typedef proto::functional::make_expr< proto::tag::bitwise_or_assign > ;
      typedef proto::functional::make_expr< proto::tag::bitwise_xor_assign > ;
      typedef proto::functional::make_expr< proto::tag::subscript > ;
      typedef proto::functional::make_expr< proto::tag::if_else_ > ;
      typedef proto::functional::make_expr< proto::tag::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++


  
    
      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.


  
    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> 
      proto::result_of::as_expr<  ();
    template<typename T> 
      proto::result_of::as_expr<  ();
    template<typename Domain, typename T> 
      proto::result_of::as_expr<  ();
    template<typename Domain, typename T> 
      proto::result_of::as_expr<  
      ();
    template<typename T> 
      proto::result_of::as_child<  ();
    template<typename T> 
      proto::result_of::as_child<  ();
    template<typename Domain, typename T> 
      proto::result_of::as_child<  ();
    template<typename Domain, typename T> 
      proto::result_of::as_child<  
      ();
    template<typename N, typename Expr> 
      proto::result_of::child<  ();
    template<typename N, typename Expr> 
      proto::result_of::child<  
      ();
    template<typename Expr> 
      proto::result_of::child<  ();
    template<typename Expr> 
      proto::result_of::child<  
      ();
    template< N, typename Expr> 
      proto::result_of::child_c<  ();
    template< N, typename Expr> 
      proto::result_of::child_c<  
      ();
    template<typename Expr> 
      proto::result_of::value<  ();
    template<typename Expr> 
      proto::result_of::value<  
      ();
    template<typename Expr> 
      proto::result_of::left<  ();
    template<typename Expr> 
      proto::result_of::left<  ();
    template<typename Expr> 
      proto::result_of::right<  ();
    template<typename Expr> 
      proto::result_of::right<  
      ();
    
      template<typename Domain = proto::default_domain> struct as_expr;
      template<typename Domain = proto::default_domain> struct as_child;
      template< N> struct child_c;
      template<typename N> struct child;
      struct value;
      struct left;
      struct right;
    }
    
      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> struct child;
      template<typename Expr> struct value;
      template<typename Expr> struct left;
      template<typename Expr> struct right;
      template<typename Expr,  N> struct child_c;
    }
  }
}

Includes all the built-in transforms of Proto.

Contains definition of the childN transforms and friends.


  
    struct _expr;
    struct _state;
    struct _data;
    template< N> struct _child_c;
    struct _value;
    struct _void;
    struct _byref;
    struct _byval;
  }
}

Contains definition of the call<> transform.


  
    template<typename T> struct call;
  }
}

  
    template<typename Grammar> struct _default;
  }
}

BOOST_PROTO_DEFINE_ENV_VAR(Type, Name)

  
    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  data;

    template<typename Key> struct _env_var;
    struct _env;
    template<typename T> 
      proto::result_of::as_env< ();
    template<typename T> 
      proto::result_of::as_env< ();
    template<typename Key, typename Env> 
      proto::result_of::has_env_var< 
      ();
    template<typename Key, typename Env> 
      proto::result_of::has_env_var< 
      ();
    template<typename Key, typename Env> 
      proto::result_of::env_var< ();
    template<typename Key, typename Env> 
      proto::result_of::env_var< 
      ();
    template<typename Env, typename Key, typename Value> 
      proto::env<(proto::result_of::as_env< 
      (, proto::env<);
    template<typename Env, typename Key, typename Value> 
      proto::env<(proto::result_of::as_env< 
      (, proto::env<);
    
      struct as_env;
      template<typename Key> struct has_env_var;
      template<typename Key> struct env_var;
    }
    
      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.


  
    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.


  
    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.


  
    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.


  
    template<typename T,  I> struct integral_c;
    template< I> struct char_;
    template< I> struct int_;
    template< I> struct long_;
    template< I> struct size_t;
  }
}

Contains definition of the proto::lazy<> transform.


  
    template<typename T> struct lazy;
  }
}

Contains definition of the proto::make<> and proto::protect<> transforms.


  
    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<>.


  
    template<typename Grammar, typename Domain = proto::deduce_domain> 
      struct pass_through;
  }
}

Definition of the proto::when<> and proto::otherwise<> transforms.


  
    struct transforms_type;

    proto::transforms_type  transforms;

    template<typename Grammar, typename PrimitiveTransform> struct when;

    template<typename Grammar, typename Fun> struct when<, >;
    template<typename Grammar, typename R, typename... A> struct when<, >;
    template<typename Grammar, typename R, typename... A> struct when<, >;
    template<typename Grammar> struct when<, 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.


  
    
      template<typename Expr, typename Context> struct callable_eval;
      template<typename Context, 
               typename DefaultCtx = proto::context::default_context> 
        struct callable_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.


  
    
      template<typename Expr, typename Context> struct null_eval;
      struct null_context;
    }
  }
}

PrevUpHomeNext