Boost  v1.57.0
doxygen for www.boost.org
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
Namespaces | Classes | Typedefs | Functions | Variables
phoenix Namespace Reference

Namespaces

 impl
 
 tuple_index_names
 

Classes

struct  actor
 
struct  actor_result
 
struct  and_assign_op
 
struct  and_op
 
struct  argument
 
struct  as_actor
 
struct  as_actor< actor< BaseT > >
 
struct  as_actor< nil_t >
 
struct  as_actor< T[N]>
 
struct  as_actor< void >
 
struct  assign_op
 
struct  binary_operator
 
struct  binary_operator<and_assign_op, T0, T1 >
 
struct  binary_operator<and_op, T0, T1 >
 
struct  binary_operator<assign_op, T0, T1 >
 
struct  binary_operator<divide_assign_op, T0, T1 >
 
struct  binary_operator<divide_op, T0, T1 >
 
struct  binary_operator<eq_op, T0, T1 >
 
struct  binary_operator<gt_eq_op, T0, T1 >
 
struct  binary_operator<gt_op, T0, T1 >
 
struct  binary_operator<index_op, nil_t, T1 >
 
struct  binary_operator<index_op, T0 *, T1 >
 
struct  binary_operator<index_op, T0 *const, T1 >
 
struct  binary_operator<index_op, T0 const, T1 >
 
struct  binary_operator<index_op, T0, T1 >
 
struct  binary_operator<index_op, T0[N], T1 >
 
struct  binary_operator<logical_and_op, T0, T1 >
 
struct  binary_operator<logical_or_op, T0, T1 >
 
struct  binary_operator<lt_eq_op, T0, T1 >
 
struct  binary_operator<lt_op, T0, T1 >
 
struct  binary_operator<minus_assign_op, T0, T1 >
 
struct  binary_operator<minus_op, T0, T1 >
 
struct  binary_operator<mod_assign_op, T0, T1 >
 
struct  binary_operator<mod_op, T0, T1 >
 
struct  binary_operator<not_eq_op, T0, T1 >
 
struct  binary_operator<or_assign_op, T0, T1 >
 
struct  binary_operator<or_op, T0, T1 >
 
struct  binary_operator<plus_assign_op, T0, T1 >
 
struct  binary_operator<plus_op, T0, T1 >
 
struct  binary_operator<shift_l_assign_op, T0, T1 >
 
struct  binary_operator<shift_l_op, std::ostream, T1 >
 
struct  binary_operator<shift_l_op, std::stringstream, T1 >
 
struct  binary_operator<shift_l_op, T0, T1 >
 
struct  binary_operator<shift_r_assign_op, T0, T1 >
 
struct  binary_operator<shift_r_op, std::istream, T1 >
 
struct  binary_operator<shift_r_op, std::stringstream, T1 >
 
struct  binary_operator<shift_r_op, T0, T1 >
 
struct  binary_operator<times_assign_op, T0, T1 >
 
struct  binary_operator<times_op, T0, T1 >
 
struct  binary_operator<xor_assign_op, T0, T1 >
 
struct  binary_operator<xor_op, T0, T1 >
 
struct  bound_member
 
struct  bound_member_action
 
struct  bound_member_action< RT, ClassT, A, B, nil_t, nil_t >
 
struct  bound_member_action< RT, ClassT, A, nil_t, nil_t, nil_t >
 
struct  bound_member_action< RT, ClassT, nil_t, nil_t, nil_t, nil_t >
 
class  closure
 
class  closure_frame
 
class  closure_member
 
struct  composite
 
struct  composite0_result
 
struct  composite1_result
 
struct  composite2_result
 
struct  composite3_result
 
struct  composite< OperationT, A, B, C, nil_t >
 
struct  composite< OperationT, A, B, nil_t, nil_t >
 
struct  composite< OperationT, A, nil_t, nil_t, nil_t >
 
struct  composite< OperationT, nil_t, nil_t, nil_t, nil_t >
 
struct  concat_tuple
 
struct  concat_tuple< tuple< A >, AppendT >
 
struct  concat_tuple< tuple< A >, nil_t >
 
struct  concat_tuple< tuple< A, B >, AppendT >
 
struct  concat_tuple< tuple< A, B >, nil_t >
 
struct  concat_tuple< tuple<>, AppendT >
 
struct  concat_tuple< tuple<>, nil_t >
 
struct  concat_tuple_element
 
struct  concat_tuple_element< TupleT1, TupleT2, N, nil_t >
 
struct  concat_tuples
 
struct  const_cast_l
 
struct  construct_1
 
struct  construct_2
 
struct  construct_3
 
struct  construct_l
 
struct  construct_l_0
 
struct  dereference_op
 
struct  divide_assign_op
 
struct  divide_op
 
struct  do_composite
 
struct  do_gen
 
struct  do_gen2
 
struct  dynamic_cast_l
 
struct  else_gen
 
struct  eq_op
 
struct  for_composite
 
struct  for_gen
 
struct  function
 
struct  function_ptr
 
struct  function_ptr_action
 
struct  function_ptr_action< RT, A, B, C, nil_t >
 
struct  function_ptr_action< RT, A, B, nil_t, nil_t >
 
struct  function_ptr_action< RT, A, nil_t, nil_t, nil_t >
 
struct  function_ptr_action< RT, nil_t, nil_t, nil_t, nil_t >
 
struct  functor
 
struct  functor_action
 
struct  gt_eq_op
 
struct  gt_op
 
struct  higher_rank
 
struct  if_gen
 
struct  if_then_composite
 
struct  if_then_else_composite
 
struct  index_op
 
struct  invert_op
 
struct  logical_and_composite
 
struct  logical_not_op
 
struct  logical_or_composite
 
struct  lt_eq_op
 
struct  lt_op
 
struct  make_tuple
 
struct  make_tuple< nil_t >
 
struct  make_tuple< tuple< A, B, C > >
 
struct  member_function_ptr
 
struct  member_function_ptr_action
 
struct  member_function_ptr_action< RT, ClassT, A, B, nil_t, nil_t >
 
struct  member_function_ptr_action< RT, ClassT, A, nil_t, nil_t, nil_t >
 
struct  member_function_ptr_action< RT, ClassT, nil_t, nil_t, nil_t, nil_t >
 
struct  member_var_ptr
 
struct  member_var_ptr_action
 
struct  member_var_ptr_action_result
 
struct  minus_assign_op
 
struct  minus_op
 
struct  mod_assign_op
 
struct  mod_op
 
struct  negative_op
 
struct  new_1
 
struct  new_2
 
struct  new_3
 
struct  new_l
 
struct  new_l_0
 
struct  nil_t
 
struct  not_eq_op
 
struct  or_assign_op
 
struct  or_op
 
struct  plus_assign_op
 
struct  plus_op
 
struct  positive_op
 
struct  post_decr_op
 
struct  post_incr_op
 
struct  pre_decr_op
 
struct  pre_incr_op
 
struct  rank
 
struct  rank< bool >
 
struct  rank< char >
 
struct  rank< double >
 
struct  rank< float >
 
struct  rank< int >
 
struct  rank< long >
 
struct  rank< long double >
 
struct  rank< short >
 
struct  rank< signed char >
 
struct  rank< std::complex< T > >
 
struct  rank< T * >
 
struct  rank< T *const >
 
struct  rank< T[N]>
 
struct  rank< unsigned char >
 
struct  rank< unsigned int >
 
struct  rank< unsigned long >
 
struct  rank< unsigned short >
 
struct  rank< void >
 
struct  rank< wchar_t >
 
struct  reference_op
 
struct  reinterpret_cast_l
 
struct  sequential_composite
 
struct  shift_l_assign_op
 
struct  shift_l_op
 
struct  shift_r_assign_op
 
struct  shift_r_op
 
struct  static_cast_l
 
struct  times_assign_op
 
struct  times_op
 
struct  tuple
 
struct  tuple< A, B, C, nil_t >
 
struct  tuple< A, B, nil_t, nil_t >
 
struct  tuple< A, nil_t, nil_t, nil_t >
 
struct  tuple<>
 
struct  tuple_base
 
struct  tuple_element
 
struct  tuple_element< 0, TupleT >
 
struct  tuple_element< 1, TupleT >
 
struct  tuple_element< 2, TupleT >
 
struct  tuple_index
 
struct  unary_operator
 
struct  unary_operator<dereference_op, nil_t >
 
struct  unary_operator<dereference_op, nil_t const >
 
struct  unary_operator<dereference_op, T * >
 
struct  unary_operator<dereference_op, T *const >
 
struct  unary_operator<dereference_op, T >
 
struct  unary_operator<invert_op, T >
 
struct  unary_operator<logical_not_op, T >
 
struct  unary_operator<negative_op, T >
 
struct  unary_operator<positive_op, T >
 
struct  unary_operator<post_decr_op, T >
 
struct  unary_operator<post_incr_op, T >
 
struct  unary_operator<pre_decr_op, T >
 
struct  unary_operator<pre_incr_op, T >
 
struct  unary_operator<reference_op, T >
 
struct  unpack_tuple
 
struct  value
 
struct  variable
 
struct  while_composite
 
struct  while_gen
 
struct  xor_assign_op
 
struct  xor_op
 

Typedefs

typedef std::ios_base &(* iomanip_t )(std::ios_base &)
 
typedef std::istream &(* imanip_t )(std::istream &)
 
typedef std::ostream &(* omanip_t )(std::ostream &)
 

Functions

template<typename FuncT >
functor< FuncT > bind (FuncT func)
 
template<typename T , typename ClassT >
member_var_ptr< T, ClassT > bind (T ClassT::*mp)
 
template<typename RT >
function_ptr< RT > bind (RT(*fptr)())
 
template<typename RT , typename A >
function_ptr< RT, A > bind (RT(*fptr)(A))
 
template<typename RT , typename A , typename B >
function_ptr< RT, A, B > bind (RT(*fptr)(A, B))
 
template<typename RT , typename A , typename B , typename C >
function_ptr< RT, A, B, C > bind (RT(*fptr)(A, B, C))
 
template<typename RT , typename ClassT >
member_function_ptr< RT, ClassT > bind (RT(ClassT::*fptr)())
 
template<typename RT , typename ClassT >
member_function_ptr< RT,
ClassT const > 		bind (RT(ClassT::*fptr)() const)
 
template<typename RT , typename ClassT , typename A >
member_function_ptr< RT,
ClassT, A > 		bind (RT(ClassT::*fptr)(A))
 
template<typename RT , typename ClassT , typename A >
member_function_ptr< RT,
ClassT const, A > 		bind (RT(ClassT::*fptr)(A) const)
 
template<typename RT , typename ClassT , typename A , typename B >
member_function_ptr< RT,
ClassT, A, B > 		bind (RT(ClassT::*fptr)(A, B))
 
template<typename RT , typename ClassT , typename A , typename B >
member_function_ptr< RT,
ClassT const, A, B > 		bind (RT(ClassT::*fptr)(A, B) const)
 
template<typename RT , typename ClassT >
bound_member< RT, ClassT > bind (ClassT &obj, RT(ClassT::*fptr)())
 
template<typename RT , typename ClassT >
bound_member< RT, ClassT > bind (ClassT *obj, RT(ClassT::*fptr)())
 
template<typename RT , typename ClassT >
bound_member< RT, ClassT const > bind (ClassT const &obj, RT(ClassT::*fptr)())
 
template<typename RT , typename ClassT >
bound_member< RT, ClassT const > bind (ClassT const *obj, RT(ClassT::*fptr)() const)
 
template<typename RT , typename ClassT , typename A >
bound_member< RT, ClassT, A > bind (ClassT &obj, RT(ClassT::*fptr)(A))
 
template<typename RT , typename ClassT , typename A >
bound_member< RT, ClassT, A > bind (ClassT *obj, RT(ClassT::*fptr)(A))
 
template<typename RT , typename ClassT , typename A >
bound_member< RT, ClassT const, A > bind (ClassT const &obj, RT(ClassT::*fptr)(A) const)
 
template<typename RT , typename ClassT , typename A >
bound_member< RT, ClassT const, A > bind (ClassT const *obj, RT(ClassT::*fptr)(A) const)
 
template<typename RT , typename ClassT , typename A , typename B >
bound_member< RT, ClassT, A, B > bind (ClassT &obj, RT(ClassT::*fptr)(A, B))
 
template<typename RT , typename ClassT , typename A , typename B >
bound_member< RT, ClassT, A, B > bind (ClassT *obj, RT(ClassT::*fptr)(A, B))
 
template<typename RT , typename ClassT , typename A , typename B >
bound_member< RT, ClassT const,
A, B > 		bind (ClassT const &obj, RT(ClassT::*fptr)(A, B) const)
 
template<typename RT , typename ClassT , typename A , typename B >
bound_member< RT, ClassT const,
A, B > 		bind (ClassT const *obj, RT(ClassT::*fptr)(A, B) const)
 
 BOOST_STATIC_ASSERT (PHOENIX_LIMIT<=PHOENIX_LIMIT)
 
template<typename T , typename BaseAT >
actor< static_cast_l< T, BaseAT > > static_cast_ (actor< BaseAT > const &a)
 
template<typename T , typename BaseAT >
actor< dynamic_cast_l< T,
BaseAT > > 		dynamic_cast_ (actor< BaseAT > const &a)
 
template<typename T , typename BaseAT >
actor< reinterpret_cast_l< T,
BaseAT > > 		reinterpret_cast_ (actor< BaseAT > const &a)
 
template<typename T , typename BaseAT >
actor< const_cast_l< T, BaseAT > > const_cast_ (actor< BaseAT > const &a)
 
template<typename T >
impl::make_composite
< construct_l_0< T > >::type 		construct_ ()
 
template<typename T , typename A >
impl::make_composite
< construct_1< T >, A >::type 		construct_ (A const &a)
 
template<typename T , typename A , typename B >
impl::make_composite
< construct_2< T >, A, B >
::type 		construct_ (A const &a, B const &b)
 
template<typename T , typename A , typename B , typename C >
impl::make_composite
< construct_3< T >, A, B, C >
::type 		construct_ (A const &a, B const &b, C const &c)
 
template<typename T >
impl::make_composite< new_l_0
< T > >::type 		new_ ()
 
template<typename T , typename A >
impl::make_composite< new_1< T >
, A >::type 		new_ (A const &a)
 
template<typename T , typename A , typename B >
impl::make_composite< new_2< T >
, A, B >::type 		new_ (A const &a, B const &b)
 
template<typename T , typename A , typename B , typename C >
impl::make_composite< new_3< T >
, A, B, C >::type 		new_ (A const &a, B const &b, C const &c)
 
template<typename BaseT >
impl::make_unary< negative_op,
BaseT >::type 		operator- (actor< BaseT > const &_0)
 
template<typename BaseT >
impl::make_unary< positive_op,
BaseT >::type 		operator+ (actor< BaseT > const &_0)
 
template<typename BaseT >
impl::make_unary
< logical_not_op, BaseT >
::type 		operator! (actor< BaseT > const &_0)
 
template<typename BaseT >
impl::make_unary< invert_op,
BaseT >::type 		operator~ (actor< BaseT > const &_0)
 
template<typename BaseT >
impl::make_unary< reference_op,
BaseT >::type 		operator& (actor< BaseT > const &_0)
 
template<typename BaseT >
impl::make_unary
< dereference_op, BaseT >
::type 		operator* (actor< BaseT > const &_0)
 
template<typename BaseT >
impl::make_unary< pre_incr_op,
BaseT >::type 		operator++ (actor< BaseT > const &_0)
 
template<typename BaseT >
impl::make_unary< pre_decr_op,
BaseT >::type 		operator-- (actor< BaseT > const &_0)
 
template<typename BaseT >
impl::make_unary< post_incr_op,
BaseT >::type 		operator++ (actor< BaseT > const &_0, int)
 
template<typename BaseT >
impl::make_unary< post_decr_op,
BaseT >::type 		operator-- (actor< BaseT > const &_0, int)
 
template<typename BaseT , typename T1 >
impl::make_binary1
< plus_assign_op, BaseT, T1 >
::type 		operator+= (actor< BaseT > const &_0, T1 _1)
 
template<typename BaseT , typename T1 >
impl::make_binary1
< minus_assign_op, BaseT, T1 >
::type 		operator-= (actor< BaseT > const &_0, T1 _1)
 
template<typename BaseT , typename T1 >
impl::make_binary1
< times_assign_op, BaseT, T1 >
::type 		operator*= (actor< BaseT > const &_0, T1 _1)
 
template<typename BaseT , typename T1 >
impl::make_binary1
< divide_assign_op, BaseT, T1 >
::type 		operator/= (actor< BaseT > const &_0, T1 _1)
 
template<typename BaseT , typename T1 >
impl::make_binary1
< mod_assign_op, BaseT, T1 >
::type 		operator%= (actor< BaseT > const &_0, T1 _1)
 
template<typename BaseT , typename T1 >
impl::make_binary1
< and_assign_op, BaseT, T1 >
::type 		operator&= (actor< BaseT > const &_0, T1 _1)
 
template<typename BaseT , typename T1 >
impl::make_binary1
< or_assign_op, BaseT, T1 >
::type 		operator|= (actor< BaseT > const &_0, T1 _1)
 
template<typename BaseT , typename T1 >
impl::make_binary1
< xor_assign_op, BaseT, T1 >
::type 		operator^= (actor< BaseT > const &_0, T1 _1)
 
template<typename BaseT , typename T1 >
impl::make_binary1
< shift_l_assign_op, BaseT, T1 >
::type 		operator<<= (actor< BaseT > const &_0, T1 _1)
 
template<typename BaseT , typename T1 >
impl::make_binary1
< shift_r_assign_op, BaseT, T1 >
::type 		operator>>= (actor< BaseT > const &_0, T1 _1)
 
template<typename BaseT , typename T1 >
impl::make_binary1< plus_op,
BaseT, T1 >::type 		operator+ (actor< BaseT > const &_0, T1 _1)
 
template<typename T0 , typename BaseT >
impl::make_binary2< plus_op,
T0, BaseT >::type 		operator+ (T0 _0, actor< BaseT > const &_1)
 
template<typename BaseT0 , typename BaseT1 >
impl::make_binary3< plus_op,
BaseT0, BaseT1 >::type 		operator+ (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename BaseT , typename T1 >
impl::make_binary1< minus_op,
BaseT, T1 >::type 		operator- (actor< BaseT > const &_0, T1 _1)
 
template<typename T0 , typename BaseT >
impl::make_binary2< minus_op,
T0, BaseT >::type 		operator- (T0 _0, actor< BaseT > const &_1)
 
template<typename BaseT0 , typename BaseT1 >
impl::make_binary3< minus_op,
BaseT0, BaseT1 >::type 		operator- (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename BaseT , typename T1 >
impl::make_binary1< times_op,
BaseT, T1 >::type 		operator* (actor< BaseT > const &_0, T1 _1)
 
template<typename T0 , typename BaseT >
impl::make_binary2< times_op,
T0, BaseT >::type 		operator* (T0 _0, actor< BaseT > const &_1)
 
template<typename BaseT0 , typename BaseT1 >
impl::make_binary3< times_op,
BaseT0, BaseT1 >::type 		operator* (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename BaseT , typename T1 >
impl::make_binary1< divide_op,
BaseT, T1 >::type 		operator/ (actor< BaseT > const &_0, T1 _1)
 
template<typename T0 , typename BaseT >
impl::make_binary2< divide_op,
T0, BaseT >::type 		operator/ (T0 _0, actor< BaseT > const &_1)
 
template<typename BaseT0 , typename BaseT1 >
impl::make_binary3< divide_op,
BaseT0, BaseT1 >::type 		operator/ (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename BaseT , typename T1 >
impl::make_binary1< mod_op,
BaseT, T1 >::type 		operator% (actor< BaseT > const &_0, T1 _1)
 
template<typename T0 , typename BaseT >
impl::make_binary2< mod_op, T0,
BaseT >::type 		operator% (T0 _0, actor< BaseT > const &_1)
 
template<typename BaseT0 , typename BaseT1 >
impl::make_binary3< mod_op,
BaseT0, BaseT1 >::type 		operator% (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename BaseT , typename T1 >
impl::make_binary1< and_op,
BaseT, T1 >::type 		operator& (actor< BaseT > const &_0, T1 _1)
 
template<typename T0 , typename BaseT >
impl::make_binary2< and_op, T0,
BaseT >::type 		operator& (T0 _0, actor< BaseT > const &_1)
 
template<typename BaseT0 , typename BaseT1 >
impl::make_binary3< and_op,
BaseT0, BaseT1 >::type 		operator& (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename BaseT , typename T1 >
impl::make_binary1< or_op,
BaseT, T1 >::type 		operator| (actor< BaseT > const &_0, T1 _1)
 
template<typename T0 , typename BaseT >
impl::make_binary2< or_op, T0,
BaseT >::type 		operator| (T0 _0, actor< BaseT > const &_1)
 
template<typename BaseT0 , typename BaseT1 >
impl::make_binary3< or_op,
BaseT0, BaseT1 >::type 		operator| (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename BaseT , typename T1 >
impl::make_binary1< xor_op,
BaseT, T1 >::type 		operator^ (actor< BaseT > const &_0, T1 _1)
 
template<typename T0 , typename BaseT >
impl::make_binary2< xor_op, T0,
BaseT >::type 		operator^ (T0 _0, actor< BaseT > const &_1)
 
template<typename BaseT0 , typename BaseT1 >
impl::make_binary3< xor_op,
BaseT0, BaseT1 >::type 		operator^ (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename BaseT , typename T1 >
impl::make_binary1< shift_l_op,
BaseT, T1 >::type 		operator<< (actor< BaseT > const &_0, T1 _1)
 
template<typename T0 , typename BaseT >
impl::make_binary2< shift_l_op,
T0, BaseT >::type 		operator<< (T0 _0, actor< BaseT > const &_1)
 
template<typename BaseT0 , typename BaseT1 >
impl::make_binary3< shift_l_op,
BaseT0, BaseT1 >::type 		operator<< (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename BaseT , typename T1 >
impl::make_binary1< shift_r_op,
BaseT, T1 >::type 		operator>> (actor< BaseT > const &_0, T1 _1)
 
template<typename T0 , typename BaseT >
impl::make_binary2< shift_r_op,
T0, BaseT >::type 		operator>> (T0 _0, actor< BaseT > const &_1)
 
template<typename BaseT0 , typename BaseT1 >
impl::make_binary3< shift_r_op,
BaseT0, BaseT1 >::type 		operator>> (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename BaseT , typename T1 >
impl::make_binary1< eq_op,
BaseT, T1 >::type 		operator== (actor< BaseT > const &_0, T1 _1)
 
template<typename T0 , typename BaseT >
impl::make_binary2< eq_op, T0,
BaseT >::type 		operator== (T0 _0, actor< BaseT > const &_1)
 
template<typename BaseT0 , typename BaseT1 >
impl::make_binary3< eq_op,
BaseT0, BaseT1 >::type 		operator== (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename BaseT , typename T1 >
impl::make_binary1< not_eq_op,
BaseT, T1 >::type 		operator!= (actor< BaseT > const &_0, T1 _1)
 
template<typename T0 , typename BaseT >
impl::make_binary2< not_eq_op,
T0, BaseT >::type 		operator!= (T0 _0, actor< BaseT > const &_1)
 
template<typename BaseT0 , typename BaseT1 >
impl::make_binary3< not_eq_op,
BaseT0, BaseT1 >::type 		operator!= (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename BaseT , typename T1 >
impl::make_binary1< lt_op,
BaseT, T1 >::type 		operator< (actor< BaseT > const &_0, T1 _1)
 
template<typename T0 , typename BaseT >
impl::make_binary2< lt_op, T0,
BaseT >::type 		operator< (T0 _0, actor< BaseT > const &_1)
 
template<typename BaseT0 , typename BaseT1 >
impl::make_binary3< lt_op,
BaseT0, BaseT1 >::type 		operator< (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename BaseT , typename T1 >
impl::make_binary1< lt_eq_op,
BaseT, T1 >::type 		operator<= (actor< BaseT > const &_0, T1 _1)
 
template<typename T0 , typename BaseT >
impl::make_binary2< lt_eq_op,
T0, BaseT >::type 		operator<= (T0 _0, actor< BaseT > const &_1)
 
template<typename BaseT0 , typename BaseT1 >
impl::make_binary3< lt_eq_op,
BaseT0, BaseT1 >::type 		operator<= (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename BaseT , typename T1 >
impl::make_binary1< gt_op,
BaseT, T1 >::type 		operator> (actor< BaseT > const &_0, T1 _1)
 
template<typename T0 , typename BaseT >
impl::make_binary2< gt_op, T0,
BaseT >::type 		operator> (T0 _0, actor< BaseT > const &_1)
 
template<typename BaseT0 , typename BaseT1 >
impl::make_binary3< gt_op,
BaseT0, BaseT1 >::type 		operator> (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename BaseT , typename T1 >
impl::make_binary1< gt_eq_op,
BaseT, T1 >::type 		operator>= (actor< BaseT > const &_0, T1 _1)
 
template<typename T0 , typename BaseT >
impl::make_binary2< gt_eq_op,
T0, BaseT >::type 		operator>= (T0 _0, actor< BaseT > const &_1)
 
template<typename BaseT0 , typename BaseT1 >
impl::make_binary3< gt_eq_op,
BaseT0, BaseT1 >::type 		operator>= (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename BaseT , typename T1 >
actor< logical_and_composite
< actor< BaseT >, typename
as_actor< T1 >::type > > 		operator&& (actor< BaseT > const &_0, T1 _1)
 
template<typename T0 , typename BaseT >
actor< logical_and_composite
< typename as_actor< T0 >
::type, actor< BaseT > > > 		operator&& (T0 _0, actor< BaseT > const &_1)
 
template<typename BaseT0 , typename BaseT1 >
actor< logical_and_composite
< actor< BaseT0 >, actor
< BaseT1 > > > 		operator&& (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename BaseT , typename T1 >
actor< logical_or_composite
< actor< BaseT >, typename
as_actor< T1 >::type > > 		operator|| (actor< BaseT > const &_0, T1 _1)
 
template<typename T0 , typename BaseT >
actor< logical_or_composite
< typename as_actor< T0 >
::type, actor< BaseT > > > 		operator|| (T0 _0, actor< BaseT > const &_1)
 
template<typename BaseT0 , typename BaseT1 >
actor< logical_or_composite
< actor< BaseT0 >, actor
< BaseT1 > > > 		operator|| (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename T >
actor< value< T > > const val (T v)
 
template<typename BaseT >
void val (actor< BaseT > const &v)
 
template<typename T >
actor< variable< T > > const var (T &v)
 
template<typename T >
actor< variable< T const > > const const_ (T const &v)
 
template<typename BaseT >
void var (actor< BaseT > const &v)
 
template<typename BaseT >
void const_ (actor< BaseT > const &v)
 
template<typename BaseT >
impl::make_binary3< shift_r_op,
variable< std::istream >
, BaseT >::type 		operator>> (std::istream &_0, actor< BaseT > const &_1)
 
template<typename BaseT >
impl::make_binary3< shift_l_op,
variable< std::ostream >
, BaseT >::type 		operator<< (std::ostream &_0, actor< BaseT > const &_1)
 
template<typename BaseT >
impl::make_binary3< shift_r_op,
variable< std::stringstream >
, BaseT >::type 		operator>> (std::stringstream &_0, actor< BaseT > const &_1)
 
template<typename BaseT >
impl::make_binary3< shift_l_op,
variable< std::stringstream >
, BaseT >::type 		operator<< (std::stringstream &_0, actor< BaseT > const &_1)
 
template<typename BaseT >
impl::make_binary1< shift_l_op,
BaseT, imanip_t >::type 		operator>> (actor< BaseT > const &_0, imanip_t _1)
 
template<typename BaseT >
impl::make_binary1< shift_l_op,
BaseT, iomanip_t >::type 		operator>> (actor< BaseT > const &_0, iomanip_t _1)
 
template<typename BaseT >
impl::make_binary1< shift_l_op,
BaseT, omanip_t >::type 		operator<< (actor< BaseT > const &_0, omanip_t _1)
 
template<typename BaseT >
impl::make_binary1< shift_l_op,
BaseT, iomanip_t >::type 		operator<< (actor< BaseT > const &_0, iomanip_t _1)
 
template<typename BaseT0 , typename BaseT1 >
actor< sequential_composite
< actor< BaseT0 >, actor
< BaseT1 > > > 		operator, (actor< BaseT0 > const &_0, actor< BaseT1 > const &_1)
 
template<typename CondT >
if_gen< CondT > if_ (CondT const &cond)
 
template<typename CondT >
while_gen< CondT > while_ (CondT const &cond)
 
template<typename InitT , typename CondT , typename StepT >
for_gen< InitT, CondT, StepT > for_ (InitT const &init, CondT const &cond, StepT const &step)
 
template<typename TupleResultT , typename ActorTupleT >
TupleResultT convert_actors (ActorTupleT const &actor_tuple)
 

Variables

actor< argument< 0 > > const arg1 = argument<0>()
 
actor< argument< 1 > > const arg2 = argument<1>()
 
actor< argument< 2 > > const arg3 = argument<2>()
 
do_gen const do_ = do_gen()
 

Typedef Documentation

typedef std ::istream&(* phoenix::imanip_t)(std::istream &)
typedef std ::ios_base&(* phoenix::iomanip_t)(std::ios_base &)
typedef std ::ostream&(* phoenix::omanip_t)(std::ostream &)

Function Documentation

template<typename FuncT >
functor<FuncT> phoenix::bind ( FuncT  func)
inline

References boost::func.

template<typename T , typename ClassT >
member_var_ptr<T, ClassT> phoenix::bind ( T ClassT::*  mp)
inline
template<typename RT >
function_ptr<RT> phoenix::bind ( RT(*)()  fptr)
inline
template<typename RT , typename A >
function_ptr<RT, A> phoenix::bind ( RT(*)(A)  fptr)
inline
template<typename RT , typename A , typename B >
function_ptr<RT, A, B> phoenix::bind ( RT(*)(A, B)  fptr)
inline
template<typename RT , typename A , typename B , typename C >
function_ptr<RT, A, B, C> phoenix::bind ( RT(*)(A, B, C)  fptr)
inline
template<typename RT , typename ClassT >
member_function_ptr<RT, ClassT> phoenix::bind ( RT(ClassT::*)()  fptr)
inline
template<typename RT , typename ClassT >
member_function_ptr<RT, ClassT const> phoenix::bind ( RT(ClassT::*)() const  fptr)
inline
template<typename RT , typename ClassT , typename A >
member_function_ptr<RT, ClassT, A> phoenix::bind ( RT(ClassT::*)(A)  fptr)
inline
template<typename RT , typename ClassT , typename A >
member_function_ptr<RT, ClassT const, A> phoenix::bind ( RT(ClassT::*)(A) const  fptr)
inline
template<typename RT , typename ClassT , typename A , typename B >
member_function_ptr<RT, ClassT, A, B> phoenix::bind ( RT(ClassT::*)(A, B)  fptr)
inline
template<typename RT , typename ClassT , typename A , typename B >
member_function_ptr<RT, ClassT const, A, B> phoenix::bind ( RT(ClassT::*)(A, B) const  fptr)
inline
template<typename RT , typename ClassT >
bound_member<RT,ClassT> phoenix::bind ( ClassT &  obj,
RT(ClassT::*)()  fptr 
)
inline
template<typename RT , typename ClassT >
bound_member<RT,ClassT> phoenix::bind ( ClassT *  obj,
RT(ClassT::*)()  fptr 
)
inline
template<typename RT , typename ClassT >
bound_member<RT,ClassT const> phoenix::bind ( ClassT const &  obj,
RT(ClassT::*)()  fptr 
)
inline
template<typename RT , typename ClassT >
bound_member<RT,ClassT const> phoenix::bind ( ClassT const *  obj,
RT(ClassT::*)() const  fptr 
)
inline
template<typename RT , typename ClassT , typename A >
bound_member<RT, ClassT, A> phoenix::bind ( ClassT &  obj,
RT(ClassT::*)(A)  fptr 
)
inline
template<typename RT , typename ClassT , typename A >
bound_member<RT, ClassT, A> phoenix::bind ( ClassT *  obj,
RT(ClassT::*)(A)  fptr 
)
inline
template<typename RT , typename ClassT , typename A >
bound_member<RT, ClassT const, A> phoenix::bind ( ClassT const &  obj,
RT(ClassT::*)(A) const  fptr 
)
inline
template<typename RT , typename ClassT , typename A >
bound_member<RT, ClassT const, A> phoenix::bind ( ClassT const *  obj,
RT(ClassT::*)(A) const  fptr 
)
inline
template<typename RT , typename ClassT , typename A , typename B >
bound_member<RT, ClassT, A, B> phoenix::bind ( ClassT &  obj,
RT(ClassT::*)(A, B)  fptr 
)
inline
template<typename RT , typename ClassT , typename A , typename B >
bound_member<RT, ClassT, A, B> phoenix::bind ( ClassT *  obj,
RT(ClassT::*)(A, B)  fptr 
)
inline
template<typename RT , typename ClassT , typename A , typename B >
bound_member<RT, ClassT const, A, B> phoenix::bind ( ClassT const &  obj,
RT(ClassT::*)(A, B) const  fptr 
)
inline
template<typename RT , typename ClassT , typename A , typename B >
bound_member<RT, ClassT const, A, B> phoenix::bind ( ClassT const *  obj,
RT(ClassT::*)(A, B) const  fptr 
)
inline
phoenix::BOOST_STATIC_ASSERT ( PHOENIX_LIMIT<=  PHOENIX_LIMIT)

Referenced by phoenix::impl::convert_actor< N, TupleResultT, ActorTupleT >::actor_element(), convert_actors(), phoenix::tuple< A, nil_t, nil_t, nil_t >::tuple(), phoenix::tuple< A, B, nil_t, nil_t >::tuple(), and phoenix::tuple< A, B, C, nil_t >::tuple().

template<typename T >
actor<variable<T const> > const phoenix::const_ ( T const &  v)
inline
template<typename BaseT >
void phoenix::const_ ( actor< BaseT > const &  v)
template<typename T , typename BaseAT >
actor<const_cast_l<T, BaseAT> > phoenix::const_cast_ ( actor< BaseAT > const &  a)
inline

Referenced by BOOST_PHOENIX_DEFINE_EXPRESSION().

template<typename T >
impl::make_composite<construct_l_0<T> >::type phoenix::construct_ ( )
inline

References boost::detail::type.

template<typename T , typename A >
impl::make_composite<construct_1<T>, A>::type phoenix::construct_ ( A const &  a)
inline

References boost::detail::type.

template<typename T , typename A , typename B >
impl::make_composite<construct_2<T>, A, B>::type phoenix::construct_ ( A const &  a,
B const &  b 
)
inline

References boost::detail::type.

template<typename T , typename A , typename B , typename C >
impl::make_composite<construct_3<T>, A, B, C>::type phoenix::construct_ ( A const &  a,
B const &  b,
C const &  c 
)
inline

References boost::detail::type.

template<typename TupleResultT , typename ActorTupleT >
TupleResultT phoenix::convert_actors ( ActorTupleT const &  actor_tuple)

References BOOST_STATIC_ASSERT(), BOOST_STATIC_CONSTANT, boost::lambda::do_, and template.

template<typename T , typename BaseAT >
actor<dynamic_cast_l<T, BaseAT> > phoenix::dynamic_cast_ ( actor< BaseAT > const &  a)
inline

Referenced by BOOST_PHOENIX_DEFINE_EXPRESSION().

template<typename InitT , typename CondT , typename StepT >
for_gen<InitT, CondT, StepT> phoenix::for_ ( InitT const &  init,
CondT const &  cond,
StepT const &  step 
)
inline

References boost::unit_test::framework::init().

Referenced by BOOST_PHOENIX_DEFINE_EXPRESSION().

template<typename CondT >
if_gen<CondT> phoenix::if_ ( CondT const &  cond)
inline

Referenced by meta_grammar().

template<typename T >
impl::make_composite<new_l_0<T> >::type phoenix::new_ ( )
inline

References boost::detail::type.

Referenced by BOOST_PHOENIX_DEFINE_EXPRESSION_VARARG().

template<typename T , typename A >
impl::make_composite<new_1<T>, A>::type phoenix::new_ ( A const &  a)
inline

References boost::detail::type.

template<typename T , typename A , typename B >
impl::make_composite<new_2<T>, A, B>::type phoenix::new_ ( A const &  a,
B const &  b 
)
inline

References boost::detail::type.

template<typename T , typename A , typename B , typename C >
impl::make_composite<new_3<T>, A, B, C>::type phoenix::new_ ( A const &  a,
B const &  b,
C const &  c 
)
inline

References boost::detail::type.

template<typename BaseT >
impl::make_unary<logical_not_op, BaseT>::type phoenix::operator! ( actor< BaseT > const &  _0)
inline

References phoenix::impl::make_unary< OperationT, BaseT >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<not_eq_op, BaseT, T1>::type phoenix::operator!= ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename T0 , typename BaseT >
impl::make_binary2<not_eq_op, T0, BaseT>::type phoenix::operator!= ( T0  _0,
actor< BaseT > const &  _1 
)
inline

References phoenix::impl::make_binary2< OperationT, A, BaseT >::construct().

template<typename BaseT0 , typename BaseT1 >
impl::make_binary3<not_eq_op, BaseT0, BaseT1>::type phoenix::operator!= ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References phoenix::impl::make_binary3< OperationT, BaseA, BaseB >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<mod_op, BaseT, T1>::type phoenix::operator% ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename T0 , typename BaseT >
impl::make_binary2<mod_op, T0, BaseT>::type phoenix::operator% ( T0  _0,
actor< BaseT > const &  _1 
)
inline

References phoenix::impl::make_binary2< OperationT, A, BaseT >::construct().

template<typename BaseT0 , typename BaseT1 >
impl::make_binary3<mod_op, BaseT0, BaseT1>::type phoenix::operator% ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References phoenix::impl::make_binary3< OperationT, BaseA, BaseB >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<mod_assign_op, BaseT, T1>::type phoenix::operator%= ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename BaseT >
impl::make_unary<reference_op, BaseT>::type phoenix::operator& ( actor< BaseT > const &  _0)
inline

References phoenix::impl::make_unary< OperationT, BaseT >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<and_op, BaseT, T1>::type phoenix::operator& ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename T0 , typename BaseT >
impl::make_binary2<and_op, T0, BaseT>::type phoenix::operator& ( T0  _0,
actor< BaseT > const &  _1 
)
inline

References phoenix::impl::make_binary2< OperationT, A, BaseT >::construct().

template<typename BaseT0 , typename BaseT1 >
impl::make_binary3<and_op, BaseT0, BaseT1>::type phoenix::operator& ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References phoenix::impl::make_binary3< OperationT, BaseA, BaseB >::construct().

template<typename BaseT , typename T1 >
actor<logical_and_composite<actor<BaseT>, typename as_actor<T1>::type> > phoenix::operator&& ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::as_actor< T >::convert().

template<typename T0 , typename BaseT >
actor<logical_and_composite<typename as_actor<T0>::type, actor<BaseT> > > phoenix::operator&& ( T0  _0,
actor< BaseT > const &  _1 
)
inline

References boost::numeric::odeint::detail::_1, and phoenix::as_actor< T >::convert().

template<typename BaseT0 , typename BaseT1 >
actor<logical_and_composite<actor<BaseT0>, actor<BaseT1> > > phoenix::operator&& ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References boost::numeric::odeint::detail::_1.

template<typename BaseT , typename T1 >
impl::make_binary1<and_assign_op, BaseT, T1>::type phoenix::operator&= ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename BaseT >
impl::make_unary<dereference_op, BaseT>::type phoenix::operator* ( actor< BaseT > const &  _0)
inline

References phoenix::impl::make_unary< OperationT, BaseT >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<times_op, BaseT, T1>::type phoenix::operator* ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename T0 , typename BaseT >
impl::make_binary2<times_op, T0, BaseT>::type phoenix::operator* ( T0  _0,
actor< BaseT > const &  _1 
)
inline

References phoenix::impl::make_binary2< OperationT, A, BaseT >::construct().

template<typename BaseT0 , typename BaseT1 >
impl::make_binary3<times_op, BaseT0, BaseT1>::type phoenix::operator* ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References phoenix::impl::make_binary3< OperationT, BaseA, BaseB >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<times_assign_op, BaseT, T1>::type phoenix::operator*= ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename BaseT >
impl::make_unary<positive_op, BaseT>::type phoenix::operator+ ( actor< BaseT > const &  _0)
inline

References phoenix::impl::make_unary< OperationT, BaseT >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<plus_op, BaseT, T1>::type phoenix::operator+ ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename T0 , typename BaseT >
impl::make_binary2<plus_op, T0, BaseT>::type phoenix::operator+ ( T0  _0,
actor< BaseT > const &  _1 
)
inline

References phoenix::impl::make_binary2< OperationT, A, BaseT >::construct().

template<typename BaseT0 , typename BaseT1 >
impl::make_binary3<plus_op, BaseT0, BaseT1>::type phoenix::operator+ ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References phoenix::impl::make_binary3< OperationT, BaseA, BaseB >::construct().

template<typename BaseT >
impl::make_unary<pre_incr_op, BaseT>::type phoenix::operator++ ( actor< BaseT > const &  _0)
inline

References phoenix::impl::make_unary< OperationT, BaseT >::construct().

template<typename BaseT >
impl::make_unary<post_incr_op, BaseT>::type phoenix::operator++ ( actor< BaseT > const &  _0,
int   
)
inline

References phoenix::impl::make_unary< OperationT, BaseT >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<plus_assign_op, BaseT, T1>::type phoenix::operator+= ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename BaseT0 , typename BaseT1 >
actor<sequential_composite<actor<BaseT0>, actor<BaseT1> > > phoenix::operator, ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References boost::numeric::odeint::detail::_1.

template<typename BaseT >
impl::make_unary<negative_op, BaseT>::type phoenix::operator- ( actor< BaseT > const &  _0)
inline

References phoenix::impl::make_unary< OperationT, BaseT >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<minus_op, BaseT, T1>::type phoenix::operator- ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename T0 , typename BaseT >
impl::make_binary2<minus_op, T0, BaseT>::type phoenix::operator- ( T0  _0,
actor< BaseT > const &  _1 
)
inline

References phoenix::impl::make_binary2< OperationT, A, BaseT >::construct().

template<typename BaseT0 , typename BaseT1 >
impl::make_binary3<minus_op, BaseT0, BaseT1>::type phoenix::operator- ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References phoenix::impl::make_binary3< OperationT, BaseA, BaseB >::construct().

template<typename BaseT >
impl::make_unary<pre_decr_op, BaseT>::type phoenix::operator-- ( actor< BaseT > const &  _0)
inline

References phoenix::impl::make_unary< OperationT, BaseT >::construct().

template<typename BaseT >
impl::make_unary<post_decr_op, BaseT>::type phoenix::operator-- ( actor< BaseT > const &  _0,
int   
)
inline

References phoenix::impl::make_unary< OperationT, BaseT >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<minus_assign_op, BaseT, T1>::type phoenix::operator-= ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<divide_op, BaseT, T1>::type phoenix::operator/ ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename T0 , typename BaseT >
impl::make_binary2<divide_op, T0, BaseT>::type phoenix::operator/ ( T0  _0,
actor< BaseT > const &  _1 
)
inline

References phoenix::impl::make_binary2< OperationT, A, BaseT >::construct().

template<typename BaseT0 , typename BaseT1 >
impl::make_binary3<divide_op, BaseT0, BaseT1>::type phoenix::operator/ ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References phoenix::impl::make_binary3< OperationT, BaseA, BaseB >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<divide_assign_op, BaseT, T1>::type phoenix::operator/= ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<lt_op, BaseT, T1>::type phoenix::operator< ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References boost::numeric::odeint::detail::_1, and phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename T0 , typename BaseT >
impl::make_binary2<lt_op, T0, BaseT>::type phoenix::operator< ( T0  _0,
actor< BaseT > const &  _1 
)
inline

References boost::numeric::odeint::detail::_1, and phoenix::impl::make_binary2< OperationT, A, BaseT >::construct().

template<typename BaseT0 , typename BaseT1 >
impl::make_binary3<lt_op, BaseT0, BaseT1>::type phoenix::operator< ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References boost::numeric::odeint::detail::_1, and phoenix::impl::make_binary3< OperationT, BaseA, BaseB >::construct().

template<typename BaseT >
impl::make_binary3<shift_l_op, variable< std ::ostream>, BaseT>::type phoenix::operator<< ( std::ostream &  _0,
actor< BaseT > const &  _1 
)
inline

References boost::numeric::odeint::detail::_1, boost::icl::construct(), and var().

template<typename BaseT >
impl::make_binary3<shift_l_op, variable< std :: stringstream >, BaseT>::type phoenix::operator<< ( std::stringstream &  _0,
actor< BaseT > const &  _1 
)
inline

References boost::numeric::odeint::detail::_1, boost::icl::construct(), and var().

template<typename BaseT >
impl::make_binary1<shift_l_op, BaseT, omanip_t>::type phoenix::operator<< ( actor< BaseT > const &  _0,
omanip_t  _1 
)
inline

References boost::numeric::odeint::detail::_1, and phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename BaseT >
impl::make_binary1<shift_l_op, BaseT, iomanip_t>::type phoenix::operator<< ( actor< BaseT > const &  _0,
iomanip_t  _1 
)
inline

References boost::numeric::odeint::detail::_1, and phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<shift_l_op, BaseT, T1>::type phoenix::operator<< ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References boost::numeric::odeint::detail::_1, and phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename T0 , typename BaseT >
impl::make_binary2<shift_l_op, T0, BaseT>::type phoenix::operator<< ( T0  _0,
actor< BaseT > const &  _1 
)
inline

References boost::numeric::odeint::detail::_1, and phoenix::impl::make_binary2< OperationT, A, BaseT >::construct().

template<typename BaseT0 , typename BaseT1 >
impl::make_binary3<shift_l_op, BaseT0, BaseT1>::type phoenix::operator<< ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References boost::numeric::odeint::detail::_1, and phoenix::impl::make_binary3< OperationT, BaseA, BaseB >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<shift_l_assign_op, BaseT, T1>::type phoenix::operator<<= ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References boost::numeric::odeint::detail::_1, and phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<lt_eq_op, BaseT, T1>::type phoenix::operator<= ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References boost::numeric::odeint::detail::_1, and phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename T0 , typename BaseT >
impl::make_binary2<lt_eq_op, T0, BaseT>::type phoenix::operator<= ( T0  _0,
actor< BaseT > const &  _1 
)
inline

References boost::numeric::odeint::detail::_1, and phoenix::impl::make_binary2< OperationT, A, BaseT >::construct().

template<typename BaseT0 , typename BaseT1 >
impl::make_binary3<lt_eq_op, BaseT0, BaseT1>::type phoenix::operator<= ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References boost::numeric::odeint::detail::_1, and phoenix::impl::make_binary3< OperationT, BaseA, BaseB >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<eq_op, BaseT, T1>::type phoenix::operator== ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename T0 , typename BaseT >
impl::make_binary2<eq_op, T0, BaseT>::type phoenix::operator== ( T0  _0,
actor< BaseT > const &  _1 
)
inline

References phoenix::impl::make_binary2< OperationT, A, BaseT >::construct().

template<typename BaseT0 , typename BaseT1 >
impl::make_binary3<eq_op, BaseT0, BaseT1>::type phoenix::operator== ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References phoenix::impl::make_binary3< OperationT, BaseA, BaseB >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<gt_op, BaseT, T1>::type phoenix::operator> ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename T0 , typename BaseT >
impl::make_binary2<gt_op, T0, BaseT>::type phoenix::operator> ( T0  _0,
actor< BaseT > const &  _1 
)
inline

References phoenix::impl::make_binary2< OperationT, A, BaseT >::construct().

template<typename BaseT0 , typename BaseT1 >
impl::make_binary3<gt_op, BaseT0, BaseT1>::type phoenix::operator> ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References phoenix::impl::make_binary3< OperationT, BaseA, BaseB >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<gt_eq_op, BaseT, T1>::type phoenix::operator>= ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename T0 , typename BaseT >
impl::make_binary2<gt_eq_op, T0, BaseT>::type phoenix::operator>= ( T0  _0,
actor< BaseT > const &  _1 
)
inline

References phoenix::impl::make_binary2< OperationT, A, BaseT >::construct().

template<typename BaseT0 , typename BaseT1 >
impl::make_binary3<gt_eq_op, BaseT0, BaseT1>::type phoenix::operator>= ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References phoenix::impl::make_binary3< OperationT, BaseA, BaseB >::construct().

template<typename BaseT >
impl::make_binary3<shift_r_op, variable< std ::istream>, BaseT>::type phoenix::operator>> ( std::istream &  _0,
actor< BaseT > const &  _1 
)
inline

References boost::icl::construct(), and var().

template<typename BaseT >
impl::make_binary3<shift_r_op, variable< std :: stringstream >, BaseT>::type phoenix::operator>> ( std::stringstream &  _0,
actor< BaseT > const &  _1 
)
inline

References boost::icl::construct(), and var().

template<typename BaseT >
impl::make_binary1<shift_l_op, BaseT, imanip_t>::type phoenix::operator>> ( actor< BaseT > const &  _0,
imanip_t  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename BaseT >
impl::make_binary1<shift_l_op, BaseT, iomanip_t>::type phoenix::operator>> ( actor< BaseT > const &  _0,
iomanip_t  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<shift_r_op, BaseT, T1>::type phoenix::operator>> ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename T0 , typename BaseT >
impl::make_binary2<shift_r_op, T0, BaseT>::type phoenix::operator>> ( T0  _0,
actor< BaseT > const &  _1 
)
inline

References phoenix::impl::make_binary2< OperationT, A, BaseT >::construct().

template<typename BaseT0 , typename BaseT1 >
impl::make_binary3<shift_r_op, BaseT0, BaseT1>::type phoenix::operator>> ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References phoenix::impl::make_binary3< OperationT, BaseA, BaseB >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<shift_r_assign_op, BaseT, T1>::type phoenix::operator>>= ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<xor_op, BaseT, T1>::type phoenix::operator^ ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename T0 , typename BaseT >
impl::make_binary2<xor_op, T0, BaseT>::type phoenix::operator^ ( T0  _0,
actor< BaseT > const &  _1 
)
inline

References phoenix::impl::make_binary2< OperationT, A, BaseT >::construct().

template<typename BaseT0 , typename BaseT1 >
impl::make_binary3<xor_op, BaseT0, BaseT1>::type phoenix::operator^ ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References phoenix::impl::make_binary3< OperationT, BaseA, BaseB >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<xor_assign_op, BaseT, T1>::type phoenix::operator^= ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<or_op, BaseT, T1>::type phoenix::operator| ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename T0 , typename BaseT >
impl::make_binary2<or_op, T0, BaseT>::type phoenix::operator| ( T0  _0,
actor< BaseT > const &  _1 
)
inline

References phoenix::impl::make_binary2< OperationT, A, BaseT >::construct().

template<typename BaseT0 , typename BaseT1 >
impl::make_binary3<or_op, BaseT0, BaseT1>::type phoenix::operator| ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References phoenix::impl::make_binary3< OperationT, BaseA, BaseB >::construct().

template<typename BaseT , typename T1 >
impl::make_binary1<or_assign_op, BaseT, T1>::type phoenix::operator|= ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::impl::make_binary1< OperationT, BaseT, B >::construct().

template<typename BaseT , typename T1 >
actor<logical_or_composite<actor<BaseT>, typename as_actor<T1>::type> > phoenix::operator|| ( actor< BaseT > const &  _0,
T1  _1 
)
inline

References phoenix::as_actor< T >::convert().

template<typename T0 , typename BaseT >
actor<logical_or_composite<typename as_actor<T0>::type, actor<BaseT> > > phoenix::operator|| ( T0  _0,
actor< BaseT > const &  _1 
)
inline

References boost::numeric::odeint::detail::_1, and phoenix::as_actor< T >::convert().

template<typename BaseT0 , typename BaseT1 >
actor<logical_or_composite<actor<BaseT0>, actor<BaseT1> > > phoenix::operator|| ( actor< BaseT0 > const &  _0,
actor< BaseT1 > const &  _1 
)
inline

References boost::numeric::odeint::detail::_1.

template<typename BaseT >
impl::make_unary<invert_op, BaseT>::type phoenix::operator~ ( actor< BaseT > const &  _0)
inline

References phoenix::impl::make_unary< OperationT, BaseT >::construct().

template<typename T , typename BaseAT >
actor<reinterpret_cast_l<T, BaseAT> > phoenix::reinterpret_cast_ ( actor< BaseAT > const &  a)
inline

Referenced by BOOST_PHOENIX_DEFINE_EXPRESSION().

template<typename T , typename BaseAT >
actor<static_cast_l<T, BaseAT> > phoenix::static_cast_ ( actor< BaseAT > const &  a)
inline

Referenced by BOOST_PHOENIX_DEFINE_EXPRESSION().

template<typename T >
actor<value<T> > const phoenix::val ( T  v)
inline
template<typename BaseT >
void phoenix::val ( actor< BaseT > const &  v)
template<typename T >
actor<variable<T> > const phoenix::var ( T &  v)
inline

Referenced by boost::wave::grammars::intlit_grammar::definition< ScannerT >::definition(), boost::wave::grammars::chlit_grammar::definition< ScannerT >::definition(), boost::io::group(), boost::math::detail::kurtosis_excess(), boost::math::mode(), boost::math::detail::non_central_t_quantile(), operator<<(), operator>>(), and boost::math::detail::skewness().

template<typename BaseT >
void phoenix::var ( actor< BaseT > const &  v)
template<typename CondT >
while_gen<CondT> phoenix::while_ ( CondT const &  cond)
inline

Referenced by BOOST_PHOENIX_DEFINE_EXPRESSION().

Variable Documentation

actor<argument<0> > const phoenix::arg1 = argument<0>()

Referenced by boost::statechart::fifo_scheduler< FifoWorker, Allocator >::create_processor(), boost::wave::grammars::intlit_grammar::definition< ScannerT >::definition(), boost::wave::grammars::chlit_grammar::definition< ScannerT >::definition(), boost::wave::grammars::expression_grammar::definition< ScannerT >::definition(), boost::accumulators::extractor< Feature >::operator()(), and boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::void_ptr_delete_if< Fun, Arg1 >::operator()().

actor<argument<1> > const phoenix::arg2 = argument<1>()

Referenced by boost::statechart::fifo_scheduler< FifoWorker, Allocator >::create_processor().

actor<argument<2> > const phoenix::arg3 = argument<2>()

Referenced by boost::statechart::fifo_scheduler< FifoWorker, Allocator >::create_processor().

do_gen const phoenix::do_ = do_gen()

Referenced by BOOST_PHOENIX_DEFINE_EXPRESSION(), and phoenix::do_gen::operator[]().