Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

Reference 參考

Concepts 概念
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/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/tags.hpp>
Header <boost/proto/traits.hpp>
Header <boost/proto/transform/arg.hpp>
Header <boost/proto/transform/call.hpp>
Header <boost/proto/transform/default.hpp>
Header <boost/proto/transform/fold.hpp>
Header <boost/proto/transform/fold_tree.hpp>
Header <boost/proto/transform/impl.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/callable.hpp>
Header <boost/proto/context/default.hpp>
Header <boost/proto/context/null.hpp>

Concepts 概念

Contains definitions of the proto::term<> and proto::listN<> class templates.
包含 proto::term<> proto::listN<> 類模板的定義。

namespace boost {
namespace proto {
template<typename Arg0> struct term;
template<typename... Arg> struct listN;
}
}

Includes all of Proto, except the contexts, transforms, debug utilities and Boost.Typeof registrations.
包含整個Proto,除了上下文、變換、調試工具和Boost.Typeof註冊。

Utilities for debugging Proto expression trees
用於調試Proto表達式樹的工具

namespace boost {
namespace proto {
template<typename Expr> void display_expr(Expr const &, std::ostream &);
template<typename Expr> void display_expr(Expr const &);
namespace functional {
struct display_expr;
}
}
}

Replace all nodes stored by reference by nodes stored by value.
將所有以引用方式保存的節點替換為以值方式保存。

namespace boost {
namespace proto {
template<typename Expr>
typename proto::result_of::deep_copy<Expr>::type deep_copy(Expr const &);
namespace result_of {
template<typename Expr> struct deep_copy;
}
namespace functional {
struct deep_copy;
}
}
}

Contains definition of proto::domain<> class template and helpers for defining domains with a generator and a grammar for controlling operator overloading.
包含 proto::domain<> 類模板的定義,以及以一個生成器和一個控制操作符重載的語法來定義領域的輔助物。

namespace boost {
namespace proto {
template<typename Generator = proto::default_generator,
typename Grammar = proto::_>
struct domain;
struct default_domain;
struct deduce_domain;
template<typename T> struct is_domain;
template<typename T> struct domain_of;
}
}

Contains the proto::eval() expression evaluator.
包含 proto::eval() 表達式求值器。

namespace boost {
namespace proto {
template<typename Expr, typename Context>
typename proto::result_of::eval< Expr, Context >::type
eval(Expr &, Context &);
template<typename Expr, typename Context>
typename proto::result_of::eval< Expr, Context >::type
eval(Expr &, Context const &);
namespace functional {
struct eval;
}
namespace result_of {
template<typename Expr, typename Context> struct eval;
}
}
}
namespace boost {
namespace proto {
template<typename Tag, typename Args, long Arity = Args::arity> struct expr;
template<typename Expr> struct unexpr;
}
}

Macros and a base class for defining end-user expression types
用於定義最終用戶的表達式類型的宏和基類。

BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain)
BOOST_PROTO_EXTENDS_ASSIGN()
BOOST_PROTO_EXTENDS_SUBSCRIPT()
BOOST_PROTO_EXTENDS_FUNCTION()
BOOST_PROTO_EXTENDS(Expr, Derived, Domain)
namespace boost {
namespace proto {
struct is_proto_expr;
template<typename Expr, typename Derived,
typename Domain = proto::default_domain>
struct extends;
}
}

Make any Proto expression a valid Fusion sequence
將任意Proto表達式變為一個有效Fusion序列

namespace boost {
namespace proto {
template<typename Expr>
typename proto::result_of::flatten< Expr const >::type
flatten(Expr const &);
namespace functional {
struct flatten;
struct pop_front;
struct reverse;
}
namespace result_of {
template<typename Expr> struct flatten;
}
}
}

Contains definition of proto::generator<> class template and friends that end users can use to generate domain-specific expression wrappers.
包含 proto::generator<> 類模板及友元的定義,最終用戶可以用它來生成領域專用表達式的包裝器。

namespace boost {
namespace proto {
struct default_generator;
template<template< typename > class Extends> struct generator;
template<template< typename > class Extends> struct pod_generator;
struct by_value_generator;
template<typename First, typename Second> struct compose_generators;
}
}

The proto::literal<> terminal wrapper, and the proto::lit() function for creating proto::literal<> wrappers.
proto::literal<> 終結符包裝器,以及用於創建 proto::literal<> 包裝器的 proto::lit() 函數。

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.
proto::make_expr() proto::unpack_expr() 工具的定義,分別用於從子節點或從子節點的一個Fusion序列構建Proto表達式。

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.
包含 proto::matches<> 元函數的定義,用於判斷一個給定的表達式是否匹配給定的模式。

namespace boost {
namespace proto {
struct _;
template<typename Grammar> struct not_;
template<typename If, typename Then = proto::_,
typename Else = proto::not_<proto::_> >
struct if_;
template<typename... G> struct or_;
template<typename... G> struct and_;
template<typename Cases> struct switch_;
template<typename T> struct exact;
template<typename T> struct convertible_to;
template<typename Grammar> struct vararg;
template<typename Expr, typename Grammar> struct matches;
}
}

Contains all the overloaded operators that make it possible to build Proto expression trees.
包含可以構建Proto表達式樹的所有重載操作符。

BOOST_PROTO_DEFINE_OPERATORS(Trait, Domain)
namespace boost {
namespace proto {
template<typename T> struct is_extension;
template<typename Arg> unspecified operator+(Arg & arg);
template<typename Arg> unspecified operator+(Arg const & arg);
template<typename Arg> unspecified operator-(Arg & arg);
template<typename Arg> unspecified operator-(Arg const & arg);
template<typename Arg> unspecified operator*(Arg & arg);
template<typename Arg> unspecified operator*(Arg const & arg);
template<typename Arg> unspecified operator~(Arg & arg);
template<typename Arg> unspecified operator~(Arg const & arg);
template<typename Arg> unspecified operator&(Arg & arg);
template<typename Arg> unspecified operator&(Arg const & arg);
template<typename Arg> unspecified operator!(Arg & arg);
template<typename Arg> unspecified operator!(Arg const & arg);
template<typename Arg> unspecified operator++(Arg & arg);
template<typename Arg> unspecified operator++(Arg const & arg);
template<typename Arg> unspecified operator--(Arg & arg);
template<typename Arg> unspecified operator--(Arg const & arg);
template<typename Arg> unspecified operator++(Arg & arg, int);
template<typename Arg> unspecified operator++(Arg const & arg, int);
template<typename Arg> unspecified operator--(Arg & arg, int);
template<typename Arg> unspecified operator--(Arg const & arg, int);
template<typename Left, typename Right>
unspecified operator<<(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator<<(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator<<(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator<<(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator>>(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator>>(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator>>(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator>>(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator*(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator*(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator*(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator*(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator/(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator/(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator/(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator/(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator%(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator%(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator%(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator%(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator+(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator+(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator+(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator+(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator-(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator-(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator-(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator-(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator<(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator<(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator<(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator<(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator>(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator>(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator>(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator>(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator<=(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator<=(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator<=(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator<=(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator>=(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator>=(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator>=(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator>=(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator==(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator==(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator==(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator==(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator!=(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator!=(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator!=(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator!=(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator||(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator||(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator||(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator||(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator&&(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator&&(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator&&(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator&&(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator&(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator&(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator&(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator&(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator|(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator|(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator|(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator|(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator^(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator^(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator^(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator^(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator,(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator,(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator,(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator,(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator->*(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator->*(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator->*(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator->*(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator<<=(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator<<=(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator<<=(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator<<=(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator>>=(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator>>=(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator>>=(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator>>=(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator*=(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator*=(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator*=(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator*=(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator/=(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator/=(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator/=(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator/=(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator%=(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator%=(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator%=(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator%=(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator+=(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator+=(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator+=(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator+=(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator-=(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator-=(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator-=(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator-=(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator&=(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator&=(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator&=(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator&=(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator|=(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator|=(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator|=(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator|=(Left const & left, Right const & right);
template<typename Left, typename Right>
unspecified operator^=(Left & left, Right & right);
template<typename Left, typename Right>
unspecified operator^=(Left & left, Right const & right);
template<typename Left, typename Right>
unspecified operator^=(Left const & left, Right & right);
template<typename Left, typename Right>
unspecified operator^=(Left const & left, Right const & right);
template<typename A0, typename A1, typename A2>
typename proto::result_of::make_expr<
proto::tag::if_else_,
proto::deduce_domain,
A0 const &,
A1 const &,
A2 const &
>::type const

if_else(A0 const & a0, A1 const & a1, A2 const & a2);
namespace exops {
BOOST_PROTO_DEFINE_OPERATORS (is_extension, default_domain);
}
}
}

Includes all of Proto, except the Boost.Typeof registrations.
包含整個Proto,除了Boost.Typeof註冊。

Forward declarations of all of proto's public types and functions.
所有proto公有類型和函數的前向聲明。

BOOST_PROTO_MAX_ARITY
BOOST_PROTO_MAX_LOGICAL_ARITY
BOOST_PROTO_MAX_FUNCTION_CALL_ARITY
namespace boost {
namespace proto {
struct callable;

int const N;

typedef proto::functional::flatten _flatten;
typedef proto::functional::pop_front _pop_front;
typedef proto::functional::reverse _reverse;
typedef proto::functional::eval _eval;
typedef proto::functional::deep_copy _deep_copy;
typedef proto::functional::make_expr< proto::tag::terminal > _make_terminal;
typedef proto::functional::make_expr< proto::tag::unary_plus > _make_unary_plus;
typedef proto::functional::make_expr< proto::tag::negate > _make_negate;
typedef proto::functional::make_expr< proto::tag::dereference > _make_dereference;
typedef proto::functional::make_expr< proto::tag::complement > _make_complement;
typedef proto::functional::make_expr< proto::tag::address_of > _make_address_of;
typedef proto::functional::make_expr< proto::tag::logical_not > _make_logical_not;
typedef proto::functional::make_expr< proto::tag::pre_inc > _make_pre_inc;
typedef proto::functional::make_expr< proto::tag::pre_dec > _make_pre_dec;
typedef proto::functional::make_expr< proto::tag::post_inc > _make_post_inc;
typedef proto::functional::make_expr< proto::tag::post_dec > _make_post_dec;
typedef proto::functional::make_expr< proto::tag::shift_left > _make_shift_left;
typedef proto::functional::make_expr< proto::tag::shift_right > _make_shift_right;
typedef proto::functional::make_expr< proto::tag::multiplies > _make_multiplies;
typedef proto::functional::make_expr< proto::tag::divides > _make_divides;
typedef proto::functional::make_expr< proto::tag::modulus > _make_modulus;
typedef proto::functional::make_expr< proto::tag::plus > _make_plus;
typedef proto::functional::make_expr< proto::tag::minus > _make_minus;
typedef proto::functional::make_expr< proto::tag::less > _make_less;
typedef proto::functional::make_expr< proto::tag::greater > _make_greater;
typedef proto::functional::make_expr< proto::tag::less_equal > _make_less_equal;
typedef proto::functional::make_expr< proto::tag::greater_equal > _make_greater_equal;
typedef proto::functional::make_expr< proto::tag::equal_to > _make_equal_to;
typedef proto::functional::make_expr< proto::tag::not_equal_to > _make_not_equal_to;
typedef proto::functional::make_expr< proto::tag::logical_or > _make_logical_or;
typedef proto::functional::make_expr< proto::tag::logical_and > _make_logical_and;
typedef proto::functional::make_expr< proto::tag::bitwise_and > _make_bitwise_and;
typedef proto::functional::make_expr< proto::tag::bitwise_or > _make_bitwise_or;
typedef proto::functional::make_expr< proto::tag::bitwise_xor > _make_bitwise_xor;
typedef proto::functional::make_expr< proto::tag::comma > _make_comma;
typedef proto::functional::make_expr< proto::tag::mem_ptr > _make_mem_ptr;
typedef proto::functional::make_expr< proto::tag::assign > _make_assign;
typedef proto::functional::make_expr< proto::tag::shift_left_assign > _make_shift_left_assign;
typedef proto::functional::make_expr< proto::tag::shift_right_assign > _make_shift_right_assign;
typedef proto::functional::make_expr< proto::tag::multiplies_assign > _make_multiplies_assign;
typedef proto::functional::make_expr< proto::tag::divides_assign > _make_divides_assign;
typedef proto::functional::make_expr< proto::tag::modulus_assign > _make_modulus_assign;
typedef proto::functional::make_expr< proto::tag::plus_assign > _make_plus_assign;
typedef proto::functional::make_expr< proto::tag::minus_assign > _make_minus_assign;
typedef proto::functional::make_expr< proto::tag::bitwise_and_assign > _make_bitwise_and_assign;
typedef proto::functional::make_expr< proto::tag::bitwise_or_assign > _make_bitwise_or_assign;
typedef proto::functional::make_expr< proto::tag::bitwise_xor_assign > _make_bitwise_xor_assign;
typedef proto::functional::make_expr< proto::tag::subscript > _make_subscript;
typedef proto::functional::make_expr< proto::tag::if_else_ > _make_if_else;
typedef proto::functional::make_expr< proto::tag::function > _make_function;
typedef proto::_child_c< N > _childN; // For each N in [0,BOOST_PROTO_MAX_ARITY) typedef proto::_child0 _child;
typedef proto::_child0 _left;
typedef proto::_child1 _right;
namespace functional {
typedef proto::functional::make_expr< proto::tag::terminal > make_terminal;
typedef proto::functional::make_expr< proto::tag::unary_plus > make_unary_plus;
typedef proto::functional::make_expr< proto::tag::negate > make_negate;
typedef proto::functional::make_expr< proto::tag::dereference > make_dereference;
typedef proto::functional::make_expr< proto::tag::complement > make_complement;
typedef proto::functional::make_expr< proto::tag::address_of > make_address_of;
typedef proto::functional::make_expr< proto::tag::logical_not > make_logical_not;
typedef proto::functional::make_expr< proto::tag::pre_inc > make_pre_inc;
typedef proto::functional::make_expr< proto::tag::pre_dec > make_pre_dec;
typedef proto::functional::make_expr< proto::tag::post_inc > make_post_inc;
typedef proto::functional::make_expr< proto::tag::post_dec > make_post_dec;
typedef proto::functional::make_expr< proto::tag::shift_left > make_shift_left;
typedef proto::functional::make_expr< proto::tag::shift_right > make_shift_right;
typedef proto::functional::make_expr< proto::tag::multiplies > make_multiplies;
typedef proto::functional::make_expr< proto::tag::divides > make_divides;
typedef proto::functional::make_expr< proto::tag::modulus > make_modulus;
typedef proto::functional::make_expr< proto::tag::plus > make_plus;
typedef proto::functional::make_expr< proto::tag::minus > make_minus;
typedef proto::functional::make_expr< proto::tag::less > make_less;
typedef proto::functional::make_expr< proto::tag::greater > make_greater;
typedef proto::functional::make_expr< proto::tag::less_equal > make_less_equal;
typedef proto::functional::make_expr< proto::tag::greater_equal > make_greater_equal;
typedef proto::functional::make_expr< proto::tag::equal_to > make_equal_to;
typedef proto::functional::make_expr< proto::tag::not_equal_to > make_not_equal_to;
typedef proto::functional::make_expr< proto::tag::logical_or > make_logical_or;
typedef proto::functional::make_expr< proto::tag::logical_and > make_logical_and;
typedef proto::functional::make_expr< proto::tag::bitwise_and > make_bitwise_and;
typedef proto::functional::make_expr< proto::tag::bitwise_or > make_bitwise_or;
typedef proto::functional::make_expr< proto::tag::bitwise_xor > make_bitwise_xor;
typedef proto::functional::make_expr< proto::tag::comma > make_comma;
typedef proto::functional::make_expr< proto::tag::mem_ptr > make_mem_ptr;
typedef proto::functional::make_expr< proto::tag::assign > make_assign;
typedef proto::functional::make_expr< proto::tag::shift_left_assign > make_shift_left_assign;
typedef proto::functional::make_expr< proto::tag::shift_right_assign > make_shift_right_assign;
typedef proto::functional::make_expr< proto::tag::multiplies_assign > make_multiplies_assign;
typedef proto::functional::make_expr< proto::tag::divides_assign > make_divides_assign;
typedef proto::functional::make_expr< proto::tag::modulus_assign > make_modulus_assign;
typedef proto::functional::make_expr< proto::tag::plus_assign > make_plus_assign;
typedef proto::functional::make_expr< proto::tag::minus_assign > make_minus_assign;
typedef proto::functional::make_expr< proto::tag::bitwise_and_assign > make_bitwise_and_assign;
typedef proto::functional::make_expr< proto::tag::bitwise_or_assign > make_bitwise_or_assign;
typedef proto::functional::make_expr< proto::tag::bitwise_xor_assign > make_bitwise_xor_assign;
typedef proto::functional::make_expr< proto::tag::subscript > make_subscript;
typedef proto::functional::make_expr< proto::tag::if_else_ > make_if_else;
typedef proto::functional::make_expr< proto::tag::function > make_function;
}
}
}

Contains the tags for all the overloadable operators in C++
包含C++中的所有可重載操作符的標籤

namespace boost {
namespace proto {
namespace tag {
struct terminal;
struct unary_plus;
struct negate;
struct dereference;
struct complement;
struct address_of;
struct logical_not;
struct pre_inc;
struct pre_dec;
struct post_inc;
struct post_dec;
struct shift_left;
struct shift_right;
struct multiplies;
struct divides;
struct modulus;
struct plus;
struct minus;
struct less;
struct greater;
struct less_equal;
struct greater_equal;
struct equal_to;
struct not_equal_to;
struct logical_or;
struct logical_and;
struct bitwise_and;
struct bitwise_or;
struct bitwise_xor;
struct comma;
struct mem_ptr;
struct assign;
struct shift_left_assign;
struct shift_right_assign;
struct multiplies_assign;
struct divides_assign;
struct modulus_assign;
struct plus_assign;
struct minus_assign;
struct bitwise_and_assign;
struct bitwise_or_assign;
struct bitwise_xor_assign;
struct subscript;
struct if_else_;
struct function;
}
}
}

Contains definitions for child<>, child_c<>, left<>, right<>, tag_of<>, and the helper functions child(), child_c(), value(), left() and right().
包 含 child<>, child_c<>, left<>, right<>, tag_of<>, 和輔助函數 child(), child_c(), value(), left() 和 right() 的定義。

namespace boost {
namespace proto {
template<typename T> struct is_callable;
template<typename T> struct is_aggregate;

template<typename T> struct terminal;
template<typename T, typename U, typename V> struct if_else_;
template<typename T> struct unary_plus;
template<typename T> struct negate;
template<typename T> struct dereference;
template<typename T> struct complement;
template<typename T> struct address_of;
template<typename T> struct logical_not;
template<typename T> struct pre_inc;
template<typename T> struct pre_dec;
template<typename T> struct post_inc;
template<typename T> struct post_dec;
template<typename T, typename U> struct shift_left;
template<typename T, typename U> struct shift_right;
template<typename T, typename U> struct multiplies;
template<typename T, typename U> struct divides;
template<typename T, typename U> struct modulus;
template<typename T, typename U> struct plus;
template<typename T, typename U> struct minus;
template<typename T, typename U> struct less;
template<typename T, typename U> struct greater;
template<typename T, typename U> struct less_equal;
template<typename T, typename U> struct greater_equal;
template<typename T, typename U> struct equal_to;
template<typename T, typename U> struct not_equal_to;
template<typename T, typename U> struct logical_or;
template<typename T, typename U> struct logical_and;
template<typename T, typename U> struct bitwise_and;
template<typename T, typename U> struct bitwise_or;
template<typename T, typename U> struct bitwise_xor;
template<typename T, typename U> struct comma;
template<typename T, typename U> struct mem_ptr;
template<typename T, typename U> struct assign;
template<typename T, typename U> struct shift_left_assign;
template<typename T, typename U> struct shift_right_assign;
template<typename T, typename U> struct multiplies_assign;
template<typename T, typename U> struct divides_assign;
template<typename T, typename U> struct modulus_assign;
template<typename T, typename U> struct plus_assign;
template<typename T, typename U> struct minus_assign;
template<typename T, typename U> struct bitwise_and_assign;
template<typename T, typename U> struct bitwise_or_assign;
template<typename T, typename U> struct bitwise_xor_assign;
template<typename T, typename U> struct subscript;
template<typename... A> struct function;
template<typename Tag, typename T> struct unary_expr;
template<typename Tag, typename T, typename U> struct binary_expr;
template<typename Tag, typename... A> struct nary_expr;
template<typename T> struct is_expr;
template<typename Expr> struct tag_of;
template<typename Expr> struct arity_of;
template<typename T>
typename proto::result_of::as_expr< T >::type as_expr(T &);
template<typename T>
typename proto::result_of::as_expr< T const >::type as_expr(T const &);
template<typename Domain, typename T>
typename proto::result_of::as_expr< T, Domain >::type as_expr(T &);
template<typename Domain, typename T>
typename proto::result_of::as_expr< T const, Domain >::type
as_expr(T const &);
template<typename T>
typename proto::result_of::as_child< T >::type as_child(T &);
template<typename T>
typename proto::result_of::as_child< T const >::type as_child(T const &);
template<typename Domain, typename T>
typename proto::result_of::as_child< T, Domain >::type as_child(T &);
template<typename Domain, typename T>
typename proto::result_of::as_child< T const, Domain >::type
as_child(T const &);
template<typename N, typename Expr>
typename proto::result_of::child< Expr &, N >::type child(Expr &);
template<typename N, typename Expr>
typename proto::result_of::child< Expr const &, N >::type
child(Expr const &);
template<typename Expr>
typename proto::result_of::child< Expr & >::type child(Expr &);
template<typename Expr>
typename proto::result_of::child< Expr const & >::type
child(Expr const &);
template<long N, typename Expr>
typename proto::result_of::child_c< Expr &, N >::type child_c(Expr &);
template<long N, typename Expr>
typename proto::result_of::child_c< Expr const &, N >::type
child_c(Expr const &);
template<typename Expr>
typename proto::result_of::value< Expr & >::type value(Expr &);
template<typename Expr>
typename proto::result_of::value< Expr const & >::type
value(Expr const &);
template<typename Expr>
typename proto::result_of::left< Expr & >::type left(Expr &);
template<typename Expr>
typename proto::result_of::left< Expr const & >::type left(Expr const &);
template<typename Expr>
typename proto::result_of::right< Expr & >::type right(Expr &);
template<typename Expr>
typename proto::result_of::right< Expr const & >::type
right(Expr const &);
namespace functional {
template<typename Domain = proto::default_domain> struct as_expr;
template<typename Domain = proto::default_domain> struct as_child;
template<long N> struct child_c;
template<typename N = mpl::long_<0> > struct child;
struct value;
struct left;
struct right;
}
namespace result_of {
template<typename T, typename Domain = proto::default_domain>
struct as_expr;
template<typename T, typename Domain = proto::default_domain>
struct as_child;
template<typename Expr, typename N = mpl::long_<0> > struct child;
template<typename Expr> struct value;
template<typename Expr> struct left;
template<typename Expr> struct right;
template<typename Expr, long N> struct child_c;
}
}
}

Contains definition of the childN transforms and friends.
包含 childN 變換及友元的定義。

namespace boost {
namespace proto {
struct _expr;
struct _state;
struct _data;
template<int N> struct _child_c;
struct _value;
struct _byref;
struct _byval;
}
}

Contains definition of the call<> transform.
包含 call<> 變換的定義。

namespace boost {
namespace proto {
template<typename T> struct call;
}
}
namespace boost {
namespace proto {
template<typename Grammar> struct _default;
}
}

Contains definition of the fold<> and reverse_fold<> transforms.
包含 fold<> 和 reverse_fold<> 變換的定義。

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 fold_tree<> and reverse_fold_tree<> transforms.
包含 fold_tree<> 和 reverse_fold_tree<> 變換的定義。

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.
包含 transform<> 和 transform_impl<> 輔助物的定義。

namespace boost {
namespace proto {
template<typename PrimitiveTransform> struct transform;
template<typename Expr, typename State, typename Data>
struct transform_impl;
}
}

Contains definition of the lazy<> transform.
包含 lazy<> 變換的定義。

namespace boost {
namespace proto {
template<typename T> struct lazy;
}
}

Contains definition of the make<> transform.
包含 make<> 變換的定義。

namespace boost {
namespace proto {
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<>.
proto::pass_through<> 變換的定義,該變換是所有象 proto::unary_plus<>, proto::plus<>proto::nary_expr<> 這樣的表達式生成器元函數的缺省變換。

namespace boost {
namespace proto {
template<typename Grammar> struct pass_through;
}
}

Definition of when transform.
when 變換的定義。

namespace boost {
namespace proto {
template<typename Grammar, typename PrimitiveTransform = Grammar>
struct when;

template<typename Grammar, typename Fun> struct when<Grammar, Fun *>;
template<typename Grammar, typename R, typename... A>
struct when<Grammar, R(A...)>;

template<typename Fun> struct otherwise;
}
}

Definintion of proto::context::callable_context<>, an evaluation context for proto::eval() that fans out each node and calls the derived context type with the expressions constituents. If the derived context doesn't have an overload that handles this node, fall back to some other context.
定義 proto::context::callable_context<>,用於 proto::eval() 的一個求值上下文,散開各個節點,並且以表達式要素調用派生的上下文類型。如果派生的上下文中沒有處理該節點的重載,則回退至其它上下文。

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.
定義 proto::context::null_context<>,用於 proto::eval() 的一個求值上下文,僅對各子表達式進行求值,但不合並結果,返回void。

namespace boost {
namespace proto {
namespace context {
template<typename Expr, typename Context> struct null_eval;
struct null_context;
}
}
}

PrevUpHomeNext