| Home | Libraries | People | FAQ | More

### Header <boost/proto/traits.hpp>

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