cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT > Class Template Reference

Lambda expression adaptor for binary operators. More...

#include <xst_binary_adaptor.h>

List of all members.

Public Types

enum  { primitive_id_ = primitive_id_binary_adaptor, operator_id_ = PolicyAdaptorT::operator_id_, capacity_ = 1 }
typedef LhsT::dereferenced_value_T dereferenced_value_T
 Defines type of dereferenced result of binary operator expression.
typedef
xst_binary_operator_traits
< typename RhsT::value_T,
typename LhsT::value_T,
operator_id_ >::value_type 		value_T
 Defines result type of binary operator expression.
typedef value_T value_type
 Defines value type of binary operator expression.

Public Member Functions

void evaluate ()
 Evaluates encapsulated lambda expression.
value_T & lvalue_ref ()
 Returns reference to the result of lambda expression.
template<typename SubstrT >
size_t match (SubstrT &edge_)
 Implements CTTL grammar evaluation algorithm.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_stack
< std::stack< StackValueT >
& > >, xst_modulus_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator%= (std::stack< StackValueT > *pstack_)
 Lambda modulus assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< StackValueT >
>, xst_modulus_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator%= (std::stack< StackValueT > const &stack_)
 Lambda modulus assignment operator support.
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
, xst_modulus_assignment_policy
< xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator%= (xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &lambda_)
 Lambda modulus assignment operator support.
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
, xst_modulus_assignment_policy
< xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator%= (xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &lambda_)
 Lambda modulus assignment operator support.
template<typename LambdaT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< typename
LambdaT::reference_T >
, xst_modulus_assignment_policy
< LambdaT::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator%= (xst_lambda_wrap< LambdaT > const &lambda_)
 Lambda modulus assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT & >
>, xst_modulus_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator%= (RhsValueT *pvalue_)
 Lambda modulus assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT >
>, xst_modulus_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator%= (RhsValueT const &value_)
 Lambda modulus assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_stack
< std::stack< StackValueT >
& > >, xst_bitwise_and_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator&= (std::stack< StackValueT > *pstack_)
 Lambda bitwise and assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< StackValueT >
>, xst_bitwise_and_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator&= (std::stack< StackValueT > const &stack_)
 Lambda bitwise and assignment operator support.
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
, xst_bitwise_and_assignment_policy
< xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator&= (xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &lambda_)
 Lambda bitwise and assignment operator support.
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
, xst_bitwise_and_assignment_policy
< xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator&= (xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &lambda_)
 Lambda bitwise and assignment operator support.
template<typename LambdaT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< typename
LambdaT::reference_T >
, xst_bitwise_and_assignment_policy
< LambdaT::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator&= (xst_lambda_wrap< LambdaT > const &lambda_)
 Lambda bitwise and assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT & >
>, xst_bitwise_and_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator&= (RhsValueT *pvalue_)
 Lambda bitwise and assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT >
>, xst_bitwise_and_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator&= (RhsValueT const &value_)
 Lambda bitwise and assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_stack
< std::stack< StackValueT >
& > >, xst_multiplication_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator*= (std::stack< StackValueT > *pstack_)
 Lambda multiplication assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< StackValueT >
>, xst_multiplication_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator*= (std::stack< StackValueT > const &stack_)
 Lambda multiplication assignment operator support.
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
, xst_multiplication_assignment_policy
< xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator*= (xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &lambda_)
 Lambda multiplication assignment operator support.
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
, xst_multiplication_assignment_policy
< xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator*= (xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &lambda_)
 Lambda multiplication assignment operator support.
template<typename LambdaT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< typename
LambdaT::reference_T >
, xst_multiplication_assignment_policy
< LambdaT::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator*= (xst_lambda_wrap< LambdaT > const &lambda_)
 Lambda multiplication assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT & >
>, xst_multiplication_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator*= (RhsValueT *pvalue_)
 Lambda multiplication assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT >
>, xst_multiplication_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator*= (RhsValueT const &value_)
 Lambda multiplication assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_stack
< std::stack< StackValueT >
& > >, xst_addition_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator+= (std::stack< StackValueT > *pstack_)
 Lambda addition assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< StackValueT >
>, xst_addition_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator+= (std::stack< StackValueT > const &stack_)
 Lambda addition assignment operator support.
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
, xst_addition_assignment_policy
< xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator+= (xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &lambda_)
 Lambda addition assignment operator support.
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
, xst_addition_assignment_policy
< xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator+= (xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &lambda_)
 Lambda addition assignment operator support.
template<typename LambdaT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< typename
LambdaT::reference_T >
, xst_addition_assignment_policy
< LambdaT::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator+= (xst_lambda_wrap< LambdaT > const &lambda_)
 Lambda addition assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT & >
>, xst_addition_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator+= (RhsValueT *pvalue_)
 Lambda addition assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT >
>, xst_addition_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator+= (RhsValueT const &value_)
 Lambda addition assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_stack
< std::stack< StackValueT >
& > >, xst_subtraction_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator-= (std::stack< StackValueT > *pstack_)
 Lambda subtraction assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< StackValueT >
>, xst_subtraction_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator-= (std::stack< StackValueT > const &stack_)
 Lambda subtraction assignment operator support.
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
, xst_subtraction_assignment_policy
< xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator-= (xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &lambda_)
 Lambda subtraction assignment operator support.
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
, xst_subtraction_assignment_policy
< xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator-= (xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &lambda_)
 Lambda subtraction assignment operator support.
template<typename LambdaT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< typename
LambdaT::reference_T >
, xst_subtraction_assignment_policy
< LambdaT::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator-= (xst_lambda_wrap< LambdaT > const &lambda_)
 Lambda subtraction assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT & >
>, xst_subtraction_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator-= (RhsValueT *pvalue_)
 Lambda subtraction assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT >
>, xst_subtraction_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator-= (RhsValueT const &value_)
 Lambda subtraction assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_stack
< std::stack< StackValueT >
& > >, xst_division_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator/= (std::stack< StackValueT > *pstack_)
 Lambda division assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< StackValueT >
>, xst_division_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator/= (std::stack< StackValueT > const &stack_)
 Lambda division assignment operator support.
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
, xst_division_assignment_policy
< xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator/= (xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &lambda_)
 Lambda division assignment operator support.
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
, xst_division_assignment_policy
< xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator/= (xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &lambda_)
 Lambda division assignment operator support.
template<typename LambdaT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< typename
LambdaT::reference_T >
, xst_division_assignment_policy
< LambdaT::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator/= (xst_lambda_wrap< LambdaT > const &lambda_)
 Lambda division assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT & >
>, xst_division_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator/= (RhsValueT *pvalue_)
 Lambda division assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT >
>, xst_division_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator/= (RhsValueT const &value_)
 Lambda division assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_stack
< std::stack< StackValueT >
& > >, xst_left_shift_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator<<= (std::stack< StackValueT > *pstack_)
 Lambda left shift assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< StackValueT >
>, xst_left_shift_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator<<= (std::stack< StackValueT > const &stack_)
 Lambda left shift assignment operator support.
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
, xst_left_shift_assignment_policy
< xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator<<= (xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &lambda_)
 Lambda left shift assignment operator support.
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
, xst_left_shift_assignment_policy
< xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator<<= (xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &lambda_)
 Lambda left shift assignment operator support.
template<typename LambdaT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< typename
LambdaT::reference_T >
, xst_left_shift_assignment_policy
< LambdaT::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator<<= (xst_lambda_wrap< LambdaT > const &lambda_)
 Lambda left shift assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT & >
>, xst_left_shift_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator<<= (RhsValueT *pvalue_)
 Lambda left shift assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT >
>, xst_left_shift_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator<<= (RhsValueT const &value_)
 Lambda left shift assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_stack
< std::stack< StackValueT >
& > >, xst_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator= (std::stack< StackValueT > *pstack_)
 Lambda assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< StackValueT >
>, xst_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator= (std::stack< StackValueT > const &stack_)
 Lambda assignment operator support.
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
, xst_assignment_policy
< xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator= (xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &lambda_)
 Lambda assignment operator support.
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
, xst_assignment_policy
< xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator= (xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &lambda_)
 Lambda assignment operator support.
template<typename LambdaT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< typename
LambdaT::reference_T >
, xst_assignment_policy
< LambdaT::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator= (xst_lambda_wrap< LambdaT > const &lambda_)
 Lambda assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT & >
>, xst_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator= (RhsValueT *pvalue_)
 Lambda assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT >
>, xst_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator= (RhsValueT const &value_)
 Lambda assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_stack
< std::stack< StackValueT >
& > >, xst_right_shift_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator>>= (std::stack< StackValueT > *pstack_)
 Lambda right shift assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< StackValueT >
>, xst_right_shift_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator>>= (std::stack< StackValueT > const &stack_)
 Lambda right shift assignment operator support.
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
, xst_right_shift_assignment_policy
< xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator>>= (xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &lambda_)
 Lambda right shift assignment operator support.
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
, xst_right_shift_assignment_policy
< xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator>>= (xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &lambda_)
 Lambda right shift assignment operator support.
template<typename LambdaT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< typename
LambdaT::reference_T >
, xst_right_shift_assignment_policy
< LambdaT::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator>>= (xst_lambda_wrap< LambdaT > const &lambda_)
 Lambda right shift assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT & >
>, xst_right_shift_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator>>= (RhsValueT *pvalue_)
 Lambda right shift assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT >
>, xst_right_shift_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator>>= (RhsValueT const &value_)
 Lambda right shift assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_stack
< std::stack< StackValueT >
& > >, xst_bitwise_xor_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator^= (std::stack< StackValueT > *pstack_)
 Lambda bitwise exclusive or assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< StackValueT >
>, xst_bitwise_xor_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator^= (std::stack< StackValueT > const &stack_)
 Lambda bitwise exclusive or assignment operator support.
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
, xst_bitwise_xor_assignment_policy
< xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator^= (xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &lambda_)
 Lambda bitwise exclusive or assignment operator support.
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
, xst_bitwise_xor_assignment_policy
< xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator^= (xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &lambda_)
 Lambda bitwise exclusive or assignment operator support.
template<typename LambdaT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< typename
LambdaT::reference_T >
, xst_bitwise_xor_assignment_policy
< LambdaT::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator^= (xst_lambda_wrap< LambdaT > const &lambda_)
 Lambda bitwise exclusive or assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT & >
>, xst_bitwise_xor_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator^= (RhsValueT *pvalue_)
 Lambda bitwise exclusive or assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT >
>, xst_bitwise_xor_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator^= (RhsValueT const &value_)
 Lambda bitwise exclusive or assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_stack
< std::stack< StackValueT >
& > >, xst_bitwise_ior_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator|= (std::stack< StackValueT > *pstack_)
 Lambda bitwise inclusive or assignment operator support.
template<typename StackValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< StackValueT >
>, xst_bitwise_ior_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator|= (std::stack< StackValueT > const &stack_)
 Lambda bitwise inclusive or assignment operator support.
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
, xst_bitwise_ior_assignment_policy
< xst_binary_adaptor
< LambdaLhsT, LambdaRhsT,
BinaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator|= (xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &lambda_)
 Lambda bitwise inclusive or assignment operator support.
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
, xst_bitwise_ior_assignment_policy
< xst_unary_adaptor< LambdaT,
UnaryPolicyAdaptorT >
::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator|= (xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &lambda_)
 Lambda bitwise inclusive or assignment operator support.
template<typename LambdaT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< typename
LambdaT::reference_T >
, xst_bitwise_ior_assignment_policy
< LambdaT::capacity_,
xst_binary_adaptor< LhsT, RhsT,
PolicyAdaptorT >::capacity_,
primitive_id_unary_adaptor > > 		operator|= (xst_lambda_wrap< LambdaT > const &lambda_)
 Lambda bitwise inclusive or assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT & >
>, xst_bitwise_ior_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator|= (RhsValueT *pvalue_)
 Lambda bitwise inclusive or assignment operator support.
template<typename RhsValueT >
xst_binary_adaptor
< xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
, xst_lambda_wrap< xst_scalar
< RhsValueT >
>, xst_bitwise_ior_assignment_policy
< 1, xst_binary_adaptor< LhsT,
RhsT, PolicyAdaptorT >
::capacity_,
primitive_id_unary_adaptor > > 		operator|= (RhsValueT const &value_)
 Lambda bitwise inclusive or assignment operator support.
void postfix_side_effects ()
 Fulfills postfix side effects for encapsulated lambda expresion.
void prefix_side_effects ()
 Fulfills prefix side effects for encapsulated lambda expresion.
template<typename SubscriptLambdaT >
value_T & top (SubscriptLambdaT)
 Evaluates encapsulated lambda expression and returns reference to the result.
template<typename SubscriptLambdaT >
value_T top (SubscriptLambdaT) const
 Evaluates encapsulated lambda expression and returns its result.
value_T top () const
 Evaluates encapsulated lambda expression and returns its result.
 xst_binary_adaptor (xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT > const &other_)
 Copy constructor.
 xst_binary_adaptor (LhsT const &lhs_, RhsT const &rhs_)
 Constructs and initializes the object.

Detailed Description

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
class cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >

Lambda expression adaptor for binary operators.

Template Parameters:
LhsT specifies type of expression on the left hand side of binary operator.
RhsT specifies type of expression on the right hand side of binary operator.
PolicyAdaptorT specifies type of policy class implementing behavior of the binary operator.

Definition at line 83 of file xst_binary_adaptor.h.

Member Typedef Documentation

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
typedef LhsT::dereferenced_value_T cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::dereferenced_value_T

Defines type of dereferenced result of binary operator expression.

Definition at line 110 of file xst_binary_adaptor.h.

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
typedef xst_binary_operator_traits< typename RhsT::value_T, typename LhsT::value_T, operator_id_ >::value_type cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::value_T

Defines result type of binary operator expression.

Definition at line 104 of file xst_binary_adaptor.h.

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
typedef value_T cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::value_type

Defines value type of binary operator expression.

Definition at line 107 of file xst_binary_adaptor.h.

Member Enumeration Documentation

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
anonymous enum

Enumerator:
primitive_id_  Unique identifier constant of binary expression adaptor.

operator_id_  Unique identifier constant of binary operator.

capacity_  Capacity of binary expression adaptor.

Definition at line 87 of file xst_binary_adaptor.h.

00087          {
00089         primitive_id_ = primitive_id_binary_adaptor,
00090 
00092         operator_id_ = PolicyAdaptorT::operator_id_,
00093 
00095         capacity_ = 1
00096     };

Constructor & Destructor Documentation

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::xst_binary_adaptor ( LhsT const &  lhs_,
RhsT const &  rhs_ 
)

Constructs and initializes the object.

Definition at line 113 of file xst_binary_adaptor.h.

00114     : xtl_op_base_binary< LhsT, RhsT >( lhs_, rhs_ )
00115     {
00116     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::xst_binary_adaptor ( xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT > const &  other_  ) 

Copy constructor.

Definition at line 119 of file xst_binary_adaptor.h.

00120     : xtl_op_base_binary< LhsT, RhsT >( other_.m_expr_lhs, other_.m_expr_rhs )
00121     {
00122     }

Member Function Documentation

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
void cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::evaluate (  ) 

Evaluates encapsulated lambda expression.

Definition at line 125 of file xst_binary_adaptor.h.

00126     {
00127         CTTL_TRACE_DEPOSIT_JUSTIFY();
00128         CTTL_TRACE_DEPOSIT_DELAYED_CHAR( '\n' );
00129         PolicyAdaptorT::top( this->m_expr_lhs, this->m_expr_rhs );
00130     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
value_T& cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::lvalue_ref (  ) 

Returns reference to the result of lambda expression.

Definition at line 184 of file xst_binary_adaptor.h.

00185     {
00186         return PolicyAdaptorT::lvalue_ref( this->m_expr_lhs, this->m_expr_rhs );
00187     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename SubstrT >
size_t cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::match ( SubstrT &  edge_  ) 

Implements CTTL grammar evaluation algorithm.

Template Parameters:
SubstrT specifies type of parseable substring.
Parameters:
edge_ reference to the parseable substring.
Precondition:
Result of encapsulated lambda expression is integral type.
Returns:
evaluation result is determined by PolicyAdaptorT implementation.

Definition at line 152 of file xst_binary_adaptor.h.

00153     {
00154         CTTL_TRACE_LEVEL_MATCH( 'b' );
00155         CTTL_TRACE_DEPOSIT_JUSTIFY();
00156         CTTL_TRACE_DEPOSIT_DELAYED_CHAR( '\n' );
00157         return PolicyAdaptorT::match( this->m_expr_lhs, this->m_expr_rhs, edge_ );
00158     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >, xst_modulus_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator%= ( std::stack< StackValueT > *  pstack_  ) 

Lambda modulus assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
pstack_ pointer to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_modulus_assignment_policy operator policy.

Definition at line 1502 of file xst_binary_adaptor.h.

01503     {
01504         typedef xst_binary_adaptor<
01505             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01506             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
01507             xst_modulus_assignment_policy<
01508                 1, // xst_stack capacity
01509                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01510                 primitive_id_unary_adaptor
01511             >
01512         > xst_adaptor_T;
01513 
01514         return xst_adaptor_T(
01515             *this,
01516             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
01517             );
01518     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< StackValueT > >, xst_modulus_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator%= ( std::stack< StackValueT > const &  stack_  ) 

Lambda modulus assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
stack_ reference to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_modulus_assignment_policy operator policy.

Definition at line 1457 of file xst_binary_adaptor.h.

01458     {
01459         typedef xst_binary_adaptor<
01460             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01461             xst_lambda_wrap< xst_scalar< StackValueT > >,
01462             xst_modulus_assignment_policy<
01463                 1, // xst_scalar capacity
01464                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01465                 primitive_id_unary_adaptor
01466             >
01467         > xst_adaptor_T;
01468 
01469         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
01470         return xst_adaptor_T(
01471             *this,
01472             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
01473             );
01474     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >, xst_modulus_assignment_policy< xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator%= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &  lambda_  ) 

Lambda modulus assignment operator support.

Template Parameters:
LambdaLhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
LambdaRhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
BinaryPolicyAdaptorT specifies policy type of cttl_impl::xst_binary_adaptor.
Parameters:
lambda_ reference to lambda expression policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_modulus_assignment_policy operator policy.

Definition at line 1413 of file xst_binary_adaptor.h.

01414     {
01415         typedef xst_binary_adaptor<
01416             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01417             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
01418             xst_modulus_assignment_policy<
01419                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
01420                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01421                 primitive_id_unary_adaptor
01422             >
01423         > xst_adaptor_T;
01424 
01425         return xst_adaptor_T( *this, lambda_ );
01426     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >, xst_modulus_assignment_policy< xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator%= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &  lambda_  ) 

Lambda modulus assignment operator support.

Template Parameters:
LambdaT specifies type of lambda expression encapsulated by cttl_impl::xst_unary_adaptor.
PolicyAdaptorT specifies policy type of cttl_impl::xst_unary_adaptor.
Parameters:
lambda_ reference to right-hand-side lambda operand policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_modulus_assignment_policy operator policy.

Definition at line 1364 of file xst_binary_adaptor.h.

01365     {
01366         typedef xst_binary_adaptor<
01367             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01368             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
01369             xst_modulus_assignment_policy<
01370                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
01371                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01372                 primitive_id_unary_adaptor
01373             >
01374         > xst_adaptor_T;
01375 
01376         return xst_adaptor_T( *this, lambda_ );
01377     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< typename LambdaT::reference_T >, xst_modulus_assignment_policy< LambdaT::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator%= ( xst_lambda_wrap< LambdaT > const &  lambda_  ) 

Lambda modulus assignment operator support.

Template Parameters:
LambdaT specifies right-hand-side lambda primitive.
Parameters:
lambda_ reference to right-hand-side lambda operand.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_modulus_assignment_policy operator policy.

Definition at line 1319 of file xst_binary_adaptor.h.

01320     {
01321         typedef xst_binary_adaptor<
01322             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01323             xst_lambda_wrap< typename LambdaT::reference_T >,
01324             xst_modulus_assignment_policy<
01325                 LambdaT::capacity_,
01326                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01327                 primitive_id_unary_adaptor
01328             >
01329         > xst_adaptor_T;
01330 
01331         return xst_adaptor_T( *this, lambda_.make_reference() );
01332     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT& > >, xst_modulus_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator%= ( RhsValueT *  pvalue_  ) 

Lambda modulus assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of assignment.
Parameters:
pvalue_ pointer to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_modulus_assignment_policy operator policy.

Definition at line 1272 of file xst_binary_adaptor.h.

01273     {
01274         typedef xst_binary_adaptor<
01275             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01276             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01277             xst_modulus_assignment_policy<
01278                 1, // xst_scalar capacity
01279                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01280                 primitive_id_unary_adaptor
01281             >
01282         > xst_adaptor_T;
01283 
01284         return xst_adaptor_T(
01285             *this,
01286             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
01287             );
01288     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT > >, xst_modulus_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator%= ( RhsValueT const &  value_  ) 

Lambda modulus assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of the operator expression.
Parameters:
value_ reference to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_modulus_assignment_policy operator policy.

Definition at line 1229 of file xst_binary_adaptor.h.

01230     {
01231         typedef xst_binary_adaptor<
01232             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01233             xst_lambda_wrap< xst_scalar< RhsValueT > >,
01234             xst_modulus_assignment_policy<
01235                 1, // xst_scalar capacity
01236                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01237                 primitive_id_unary_adaptor
01238             >
01239         > xst_adaptor_T;
01240 
01241         return xst_adaptor_T(
01242             *this,
01243             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
01244             );
01245     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >, xst_bitwise_and_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator&= ( std::stack< StackValueT > *  pstack_  ) 

Lambda bitwise and assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
pstack_ pointer to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_and_assignment_policy operator policy.

Definition at line 3142 of file xst_binary_adaptor.h.

03143     {
03144         typedef xst_binary_adaptor<
03145             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03146             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03147             xst_bitwise_and_assignment_policy<
03148                 1, // xst_stack capacity
03149                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03150                 primitive_id_unary_adaptor
03151             >
03152         > xst_adaptor_T;
03153 
03154         return xst_adaptor_T(
03155             *this,
03156             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
03157             );
03158     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< StackValueT > >, xst_bitwise_and_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator&= ( std::stack< StackValueT > const &  stack_  ) 

Lambda bitwise and assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
stack_ reference to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_and_assignment_policy operator policy.

Definition at line 3097 of file xst_binary_adaptor.h.

03098     {
03099         typedef xst_binary_adaptor<
03100             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03101             xst_lambda_wrap< xst_scalar< StackValueT > >,
03102             xst_bitwise_and_assignment_policy<
03103                 1, // xst_scalar capacity
03104                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03105                 primitive_id_unary_adaptor
03106             >
03107         > xst_adaptor_T;
03108 
03109         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
03110         return xst_adaptor_T(
03111             *this,
03112             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
03113             );
03114     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >, xst_bitwise_and_assignment_policy< xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator&= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &  lambda_  ) 

Lambda bitwise and assignment operator support.

Template Parameters:
LambdaLhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
LambdaRhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
BinaryPolicyAdaptorT specifies policy type of cttl_impl::xst_binary_adaptor.
Parameters:
lambda_ reference to lambda expression policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_and_assignment_policy operator policy.

Definition at line 3053 of file xst_binary_adaptor.h.

03054     {
03055         typedef xst_binary_adaptor<
03056             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03057             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
03058             xst_bitwise_and_assignment_policy<
03059                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
03060                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03061                 primitive_id_unary_adaptor
03062             >
03063         > xst_adaptor_T;
03064 
03065         return xst_adaptor_T( *this, lambda_ );
03066     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >, xst_bitwise_and_assignment_policy< xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator&= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &  lambda_  ) 

Lambda bitwise and assignment operator support.

Template Parameters:
LambdaT specifies type of lambda expression encapsulated by cttl_impl::xst_unary_adaptor.
PolicyAdaptorT specifies policy type of cttl_impl::xst_unary_adaptor.
Parameters:
lambda_ reference to right-hand-side lambda operand policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_and_assignment_policy operator policy.

Definition at line 3004 of file xst_binary_adaptor.h.

03005     {
03006         typedef xst_binary_adaptor<
03007             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03008             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
03009             xst_bitwise_and_assignment_policy<
03010                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
03011                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03012                 primitive_id_unary_adaptor
03013             >
03014         > xst_adaptor_T;
03015 
03016         return xst_adaptor_T( *this, lambda_ );
03017     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< typename LambdaT::reference_T >, xst_bitwise_and_assignment_policy< LambdaT::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator&= ( xst_lambda_wrap< LambdaT > const &  lambda_  ) 

Lambda bitwise and assignment operator support.

Template Parameters:
LambdaT specifies right-hand-side lambda primitive.
Parameters:
lambda_ reference to right-hand-side lambda operand.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_and_assignment_policy operator policy.

Definition at line 2959 of file xst_binary_adaptor.h.

02960     {
02961         typedef xst_binary_adaptor<
02962             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02963             xst_lambda_wrap< typename LambdaT::reference_T >,
02964             xst_bitwise_and_assignment_policy<
02965                 LambdaT::capacity_,
02966                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02967                 primitive_id_unary_adaptor
02968             >
02969         > xst_adaptor_T;
02970 
02971         return xst_adaptor_T( *this, lambda_.make_reference() );
02972     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT& > >, xst_bitwise_and_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator&= ( RhsValueT *  pvalue_  ) 

Lambda bitwise and assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of assignment.
Parameters:
pvalue_ pointer to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_and_assignment_policy operator policy.

Definition at line 2912 of file xst_binary_adaptor.h.

02913     {
02914         typedef xst_binary_adaptor<
02915             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02916             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02917             xst_bitwise_and_assignment_policy<
02918                 1, // xst_scalar capacity
02919                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02920                 primitive_id_unary_adaptor
02921             >
02922         > xst_adaptor_T;
02923 
02924         return xst_adaptor_T(
02925             *this,
02926             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
02927             );
02928     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT > >, xst_bitwise_and_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator&= ( RhsValueT const &  value_  ) 

Lambda bitwise and assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of the operator expression.
Parameters:
value_ reference to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_and_assignment_policy operator policy.

Definition at line 2869 of file xst_binary_adaptor.h.

02870     {
02871         typedef xst_binary_adaptor<
02872             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02873             xst_lambda_wrap< xst_scalar< RhsValueT > >,
02874             xst_bitwise_and_assignment_policy<
02875                 1, // xst_scalar capacity
02876                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02877                 primitive_id_unary_adaptor
02878             >
02879         > xst_adaptor_T;
02880 
02881         return xst_adaptor_T(
02882             *this,
02883             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
02884             );
02885     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >, xst_multiplication_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator*= ( std::stack< StackValueT > *  pstack_  ) 

Lambda multiplication assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
pstack_ pointer to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_multiplication_assignment_policy operator policy.

Definition at line 846 of file xst_binary_adaptor.h.

00847     {
00848         typedef xst_binary_adaptor<
00849             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00850             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
00851             xst_multiplication_assignment_policy<
00852                 1, // xst_stack capacity
00853                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00854                 primitive_id_unary_adaptor
00855             >
00856         > xst_adaptor_T;
00857 
00858         return xst_adaptor_T(
00859             *this,
00860             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
00861             );
00862     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< StackValueT > >, xst_multiplication_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator*= ( std::stack< StackValueT > const &  stack_  ) 

Lambda multiplication assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
stack_ reference to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_multiplication_assignment_policy operator policy.

Definition at line 801 of file xst_binary_adaptor.h.

00802     {
00803         typedef xst_binary_adaptor<
00804             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00805             xst_lambda_wrap< xst_scalar< StackValueT > >,
00806             xst_multiplication_assignment_policy<
00807                 1, // xst_scalar capacity
00808                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00809                 primitive_id_unary_adaptor
00810             >
00811         > xst_adaptor_T;
00812 
00813         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
00814         return xst_adaptor_T(
00815             *this,
00816             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
00817             );
00818     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >, xst_multiplication_assignment_policy< xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator*= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &  lambda_  ) 

Lambda multiplication assignment operator support.

Template Parameters:
LambdaLhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
LambdaRhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
BinaryPolicyAdaptorT specifies policy type of cttl_impl::xst_binary_adaptor.
Parameters:
lambda_ reference to lambda expression policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_multiplication_assignment_policy operator policy.

Definition at line 757 of file xst_binary_adaptor.h.

00758     {
00759         typedef xst_binary_adaptor<
00760             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00761             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
00762             xst_multiplication_assignment_policy<
00763                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
00764                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00765                 primitive_id_unary_adaptor
00766             >
00767         > xst_adaptor_T;
00768 
00769         return xst_adaptor_T( *this, lambda_ );
00770     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >, xst_multiplication_assignment_policy< xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator*= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &  lambda_  ) 

Lambda multiplication assignment operator support.

Template Parameters:
LambdaT specifies type of lambda expression encapsulated by cttl_impl::xst_unary_adaptor.
PolicyAdaptorT specifies policy type of cttl_impl::xst_unary_adaptor.
Parameters:
lambda_ reference to right-hand-side lambda operand policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_multiplication_assignment_policy operator policy.

Definition at line 708 of file xst_binary_adaptor.h.

00709     {
00710         typedef xst_binary_adaptor<
00711             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00712             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
00713             xst_multiplication_assignment_policy<
00714                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
00715                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00716                 primitive_id_unary_adaptor
00717             >
00718         > xst_adaptor_T;
00719 
00720         return xst_adaptor_T( *this, lambda_ );
00721     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< typename LambdaT::reference_T >, xst_multiplication_assignment_policy< LambdaT::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator*= ( xst_lambda_wrap< LambdaT > const &  lambda_  ) 

Lambda multiplication assignment operator support.

Template Parameters:
LambdaT specifies right-hand-side lambda primitive.
Parameters:
lambda_ reference to right-hand-side lambda operand.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_multiplication_assignment_policy operator policy.

Definition at line 663 of file xst_binary_adaptor.h.

00664     {
00665         typedef xst_binary_adaptor<
00666             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00667             xst_lambda_wrap< typename LambdaT::reference_T >,
00668             xst_multiplication_assignment_policy<
00669                 LambdaT::capacity_,
00670                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00671                 primitive_id_unary_adaptor
00672             >
00673         > xst_adaptor_T;
00674 
00675         return xst_adaptor_T( *this, lambda_.make_reference() );
00676     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT& > >, xst_multiplication_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator*= ( RhsValueT *  pvalue_  ) 

Lambda multiplication assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of assignment.
Parameters:
pvalue_ pointer to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_multiplication_assignment_policy operator policy.

Definition at line 616 of file xst_binary_adaptor.h.

00617     {
00618         typedef xst_binary_adaptor<
00619             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00620             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
00621             xst_multiplication_assignment_policy<
00622                 1, // xst_scalar capacity
00623                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00624                 primitive_id_unary_adaptor
00625             >
00626         > xst_adaptor_T;
00627 
00628         return xst_adaptor_T(
00629             *this,
00630             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
00631             );
00632     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT > >, xst_multiplication_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator*= ( RhsValueT const &  value_  ) 

Lambda multiplication assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of the operator expression.
Parameters:
value_ reference to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_multiplication_assignment_policy operator policy.

Definition at line 573 of file xst_binary_adaptor.h.

00574     {
00575         typedef xst_binary_adaptor<
00576             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00577             xst_lambda_wrap< xst_scalar< RhsValueT > >,
00578             xst_multiplication_assignment_policy<
00579                 1, // xst_scalar capacity
00580                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00581                 primitive_id_unary_adaptor
00582             >
00583         > xst_adaptor_T;
00584 
00585         return xst_adaptor_T(
00586             *this,
00587             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
00588             );
00589     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >, xst_addition_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator+= ( std::stack< StackValueT > *  pstack_  ) 

Lambda addition assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
pstack_ pointer to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_addition_assignment_policy operator policy.

Definition at line 1830 of file xst_binary_adaptor.h.

01831     {
01832         typedef xst_binary_adaptor<
01833             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01834             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
01835             xst_addition_assignment_policy<
01836                 1, // xst_stack capacity
01837                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01838                 primitive_id_unary_adaptor
01839             >
01840         > xst_adaptor_T;
01841 
01842         return xst_adaptor_T(
01843             *this,
01844             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
01845             );
01846     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< StackValueT > >, xst_addition_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator+= ( std::stack< StackValueT > const &  stack_  ) 

Lambda addition assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
stack_ reference to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_addition_assignment_policy operator policy.

Definition at line 1785 of file xst_binary_adaptor.h.

01786     {
01787         typedef xst_binary_adaptor<
01788             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01789             xst_lambda_wrap< xst_scalar< StackValueT > >,
01790             xst_addition_assignment_policy<
01791                 1, // xst_scalar capacity
01792                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01793                 primitive_id_unary_adaptor
01794             >
01795         > xst_adaptor_T;
01796 
01797         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
01798         return xst_adaptor_T(
01799             *this,
01800             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
01801             );
01802     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >, xst_addition_assignment_policy< xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator+= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &  lambda_  ) 

Lambda addition assignment operator support.

Template Parameters:
LambdaLhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
LambdaRhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
BinaryPolicyAdaptorT specifies policy type of cttl_impl::xst_binary_adaptor.
Parameters:
lambda_ reference to lambda expression policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_addition_assignment_policy operator policy.

Definition at line 1741 of file xst_binary_adaptor.h.

01742     {
01743         typedef xst_binary_adaptor<
01744             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01745             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
01746             xst_addition_assignment_policy<
01747                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
01748                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01749                 primitive_id_unary_adaptor
01750             >
01751         > xst_adaptor_T;
01752 
01753         return xst_adaptor_T( *this, lambda_ );
01754     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >, xst_addition_assignment_policy< xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator+= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &  lambda_  ) 

Lambda addition assignment operator support.

Template Parameters:
LambdaT specifies type of lambda expression encapsulated by cttl_impl::xst_unary_adaptor.
PolicyAdaptorT specifies policy type of cttl_impl::xst_unary_adaptor.
Parameters:
lambda_ reference to right-hand-side lambda operand policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_addition_assignment_policy operator policy.

Definition at line 1692 of file xst_binary_adaptor.h.

01693     {
01694         typedef xst_binary_adaptor<
01695             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01696             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
01697             xst_addition_assignment_policy<
01698                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
01699                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01700                 primitive_id_unary_adaptor
01701             >
01702         > xst_adaptor_T;
01703 
01704         return xst_adaptor_T( *this, lambda_ );
01705     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< typename LambdaT::reference_T >, xst_addition_assignment_policy< LambdaT::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator+= ( xst_lambda_wrap< LambdaT > const &  lambda_  ) 

Lambda addition assignment operator support.

Template Parameters:
LambdaT specifies right-hand-side lambda primitive.
Parameters:
lambda_ reference to right-hand-side lambda operand.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_addition_assignment_policy operator policy.

Definition at line 1647 of file xst_binary_adaptor.h.

01648     {
01649         typedef xst_binary_adaptor<
01650             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01651             xst_lambda_wrap< typename LambdaT::reference_T >,
01652             xst_addition_assignment_policy<
01653                 LambdaT::capacity_,
01654                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01655                 primitive_id_unary_adaptor
01656             >
01657         > xst_adaptor_T;
01658 
01659         return xst_adaptor_T( *this, lambda_.make_reference() );
01660     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT& > >, xst_addition_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator+= ( RhsValueT *  pvalue_  ) 

Lambda addition assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of assignment.
Parameters:
pvalue_ pointer to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_addition_assignment_policy operator policy.

Definition at line 1600 of file xst_binary_adaptor.h.

01601     {
01602         typedef xst_binary_adaptor<
01603             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01604             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01605             xst_addition_assignment_policy<
01606                 1, // xst_scalar capacity
01607                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01608                 primitive_id_unary_adaptor
01609             >
01610         > xst_adaptor_T;
01611 
01612         return xst_adaptor_T(
01613             *this,
01614             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
01615             );
01616     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT > >, xst_addition_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator+= ( RhsValueT const &  value_  ) 

Lambda addition assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of the operator expression.
Parameters:
value_ reference to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_addition_assignment_policy operator policy.

Definition at line 1557 of file xst_binary_adaptor.h.

01558     {
01559         typedef xst_binary_adaptor<
01560             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01561             xst_lambda_wrap< xst_scalar< RhsValueT > >,
01562             xst_addition_assignment_policy<
01563                 1, // xst_scalar capacity
01564                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01565                 primitive_id_unary_adaptor
01566             >
01567         > xst_adaptor_T;
01568 
01569         return xst_adaptor_T(
01570             *this,
01571             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
01572             );
01573     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >, xst_subtraction_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator-= ( std::stack< StackValueT > *  pstack_  ) 

Lambda subtraction assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
pstack_ pointer to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_subtraction_assignment_policy operator policy.

Definition at line 2158 of file xst_binary_adaptor.h.

02159     {
02160         typedef xst_binary_adaptor<
02161             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02162             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02163             xst_subtraction_assignment_policy<
02164                 1, // xst_stack capacity
02165                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02166                 primitive_id_unary_adaptor
02167             >
02168         > xst_adaptor_T;
02169 
02170         return xst_adaptor_T(
02171             *this,
02172             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
02173             );
02174     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< StackValueT > >, xst_subtraction_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator-= ( std::stack< StackValueT > const &  stack_  ) 

Lambda subtraction assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
stack_ reference to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_subtraction_assignment_policy operator policy.

Definition at line 2113 of file xst_binary_adaptor.h.

02114     {
02115         typedef xst_binary_adaptor<
02116             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02117             xst_lambda_wrap< xst_scalar< StackValueT > >,
02118             xst_subtraction_assignment_policy<
02119                 1, // xst_scalar capacity
02120                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02121                 primitive_id_unary_adaptor
02122             >
02123         > xst_adaptor_T;
02124 
02125         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
02126         return xst_adaptor_T(
02127             *this,
02128             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
02129             );
02130     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >, xst_subtraction_assignment_policy< xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator-= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &  lambda_  ) 

Lambda subtraction assignment operator support.

Template Parameters:
LambdaLhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
LambdaRhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
BinaryPolicyAdaptorT specifies policy type of cttl_impl::xst_binary_adaptor.
Parameters:
lambda_ reference to lambda expression policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_subtraction_assignment_policy operator policy.

Definition at line 2069 of file xst_binary_adaptor.h.

02070     {
02071         typedef xst_binary_adaptor<
02072             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02073             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
02074             xst_subtraction_assignment_policy<
02075                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
02076                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02077                 primitive_id_unary_adaptor
02078             >
02079         > xst_adaptor_T;
02080 
02081         return xst_adaptor_T( *this, lambda_ );
02082     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >, xst_subtraction_assignment_policy< xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator-= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &  lambda_  ) 

Lambda subtraction assignment operator support.

Template Parameters:
LambdaT specifies type of lambda expression encapsulated by cttl_impl::xst_unary_adaptor.
PolicyAdaptorT specifies policy type of cttl_impl::xst_unary_adaptor.
Parameters:
lambda_ reference to right-hand-side lambda operand policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_subtraction_assignment_policy operator policy.

Definition at line 2020 of file xst_binary_adaptor.h.

02021     {
02022         typedef xst_binary_adaptor<
02023             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02024             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
02025             xst_subtraction_assignment_policy<
02026                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
02027                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02028                 primitive_id_unary_adaptor
02029             >
02030         > xst_adaptor_T;
02031 
02032         return xst_adaptor_T( *this, lambda_ );
02033     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< typename LambdaT::reference_T >, xst_subtraction_assignment_policy< LambdaT::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator-= ( xst_lambda_wrap< LambdaT > const &  lambda_  ) 

Lambda subtraction assignment operator support.

Template Parameters:
LambdaT specifies right-hand-side lambda primitive.
Parameters:
lambda_ reference to right-hand-side lambda operand.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_subtraction_assignment_policy operator policy.

Definition at line 1975 of file xst_binary_adaptor.h.

01976     {
01977         typedef xst_binary_adaptor<
01978             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01979             xst_lambda_wrap< typename LambdaT::reference_T >,
01980             xst_subtraction_assignment_policy<
01981                 LambdaT::capacity_,
01982                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01983                 primitive_id_unary_adaptor
01984             >
01985         > xst_adaptor_T;
01986 
01987         return xst_adaptor_T( *this, lambda_.make_reference() );
01988     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT& > >, xst_subtraction_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator-= ( RhsValueT *  pvalue_  ) 

Lambda subtraction assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of assignment.
Parameters:
pvalue_ pointer to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_subtraction_assignment_policy operator policy.

Definition at line 1928 of file xst_binary_adaptor.h.

01929     {
01930         typedef xst_binary_adaptor<
01931             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01932             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01933             xst_subtraction_assignment_policy<
01934                 1, // xst_scalar capacity
01935                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01936                 primitive_id_unary_adaptor
01937             >
01938         > xst_adaptor_T;
01939 
01940         return xst_adaptor_T(
01941             *this,
01942             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
01943             );
01944     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT > >, xst_subtraction_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator-= ( RhsValueT const &  value_  ) 

Lambda subtraction assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of the operator expression.
Parameters:
value_ reference to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_subtraction_assignment_policy operator policy.

Definition at line 1885 of file xst_binary_adaptor.h.

01886     {
01887         typedef xst_binary_adaptor<
01888             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01889             xst_lambda_wrap< xst_scalar< RhsValueT > >,
01890             xst_subtraction_assignment_policy<
01891                 1, // xst_scalar capacity
01892                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01893                 primitive_id_unary_adaptor
01894             >
01895         > xst_adaptor_T;
01896 
01897         return xst_adaptor_T(
01898             *this,
01899             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
01900             );
01901     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >, xst_division_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator/= ( std::stack< StackValueT > *  pstack_  ) 

Lambda division assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
pstack_ pointer to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_division_assignment_policy operator policy.

Definition at line 1174 of file xst_binary_adaptor.h.

01175     {
01176         typedef xst_binary_adaptor<
01177             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01178             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
01179             xst_division_assignment_policy<
01180                 1, // xst_stack capacity
01181                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01182                 primitive_id_unary_adaptor
01183             >
01184         > xst_adaptor_T;
01185 
01186         return xst_adaptor_T(
01187             *this,
01188             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
01189             );
01190     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< StackValueT > >, xst_division_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator/= ( std::stack< StackValueT > const &  stack_  ) 

Lambda division assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
stack_ reference to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_division_assignment_policy operator policy.

Definition at line 1129 of file xst_binary_adaptor.h.

01130     {
01131         typedef xst_binary_adaptor<
01132             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01133             xst_lambda_wrap< xst_scalar< StackValueT > >,
01134             xst_division_assignment_policy<
01135                 1, // xst_scalar capacity
01136                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01137                 primitive_id_unary_adaptor
01138             >
01139         > xst_adaptor_T;
01140 
01141         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
01142         return xst_adaptor_T(
01143             *this,
01144             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
01145             );
01146     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >, xst_division_assignment_policy< xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator/= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &  lambda_  ) 

Lambda division assignment operator support.

Template Parameters:
LambdaLhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
LambdaRhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
BinaryPolicyAdaptorT specifies policy type of cttl_impl::xst_binary_adaptor.
Parameters:
lambda_ reference to lambda expression policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_division_assignment_policy operator policy.

Definition at line 1085 of file xst_binary_adaptor.h.

01086     {
01087         typedef xst_binary_adaptor<
01088             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01089             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
01090             xst_division_assignment_policy<
01091                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
01092                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01093                 primitive_id_unary_adaptor
01094             >
01095         > xst_adaptor_T;
01096 
01097         return xst_adaptor_T( *this, lambda_ );
01098     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >, xst_division_assignment_policy< xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator/= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &  lambda_  ) 

Lambda division assignment operator support.

Template Parameters:
LambdaT specifies type of lambda expression encapsulated by cttl_impl::xst_unary_adaptor.
PolicyAdaptorT specifies policy type of cttl_impl::xst_unary_adaptor.
Parameters:
lambda_ reference to right-hand-side lambda operand policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_division_assignment_policy operator policy.

Definition at line 1036 of file xst_binary_adaptor.h.

01037     {
01038         typedef xst_binary_adaptor<
01039             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01040             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
01041             xst_division_assignment_policy<
01042                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
01043                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01044                 primitive_id_unary_adaptor
01045             >
01046         > xst_adaptor_T;
01047 
01048         return xst_adaptor_T( *this, lambda_ );
01049     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< typename LambdaT::reference_T >, xst_division_assignment_policy< LambdaT::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator/= ( xst_lambda_wrap< LambdaT > const &  lambda_  ) 

Lambda division assignment operator support.

Template Parameters:
LambdaT specifies right-hand-side lambda primitive.
Parameters:
lambda_ reference to right-hand-side lambda operand.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_division_assignment_policy operator policy.

Definition at line 991 of file xst_binary_adaptor.h.

00992     {
00993         typedef xst_binary_adaptor<
00994             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00995             xst_lambda_wrap< typename LambdaT::reference_T >,
00996             xst_division_assignment_policy<
00997                 LambdaT::capacity_,
00998                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00999                 primitive_id_unary_adaptor
01000             >
01001         > xst_adaptor_T;
01002 
01003         return xst_adaptor_T( *this, lambda_.make_reference() );
01004     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT& > >, xst_division_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator/= ( RhsValueT *  pvalue_  ) 

Lambda division assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of assignment.
Parameters:
pvalue_ pointer to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_division_assignment_policy operator policy.

Definition at line 944 of file xst_binary_adaptor.h.

00945     {
00946         typedef xst_binary_adaptor<
00947             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00948             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
00949             xst_division_assignment_policy<
00950                 1, // xst_scalar capacity
00951                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00952                 primitive_id_unary_adaptor
00953             >
00954         > xst_adaptor_T;
00955 
00956         return xst_adaptor_T(
00957             *this,
00958             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
00959             );
00960     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT > >, xst_division_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator/= ( RhsValueT const &  value_  ) 

Lambda division assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of the operator expression.
Parameters:
value_ reference to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_division_assignment_policy operator policy.

Definition at line 901 of file xst_binary_adaptor.h.

00902     {
00903         typedef xst_binary_adaptor<
00904             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00905             xst_lambda_wrap< xst_scalar< RhsValueT > >,
00906             xst_division_assignment_policy<
00907                 1, // xst_scalar capacity
00908                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00909                 primitive_id_unary_adaptor
00910             >
00911         > xst_adaptor_T;
00912 
00913         return xst_adaptor_T(
00914             *this,
00915             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
00916             );
00917     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >, xst_left_shift_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator<<= ( std::stack< StackValueT > *  pstack_  ) 

Lambda left shift assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
pstack_ pointer to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_left_shift_assignment_policy operator policy.

Definition at line 2486 of file xst_binary_adaptor.h.

02487     {
02488         typedef xst_binary_adaptor<
02489             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02490             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02491             xst_left_shift_assignment_policy<
02492                 1, // xst_stack capacity
02493                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02494                 primitive_id_unary_adaptor
02495             >
02496         > xst_adaptor_T;
02497 
02498         return xst_adaptor_T(
02499             *this,
02500             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
02501             );
02502     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< StackValueT > >, xst_left_shift_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator<<= ( std::stack< StackValueT > const &  stack_  ) 

Lambda left shift assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
stack_ reference to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_left_shift_assignment_policy operator policy.

Definition at line 2441 of file xst_binary_adaptor.h.

02442     {
02443         typedef xst_binary_adaptor<
02444             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02445             xst_lambda_wrap< xst_scalar< StackValueT > >,
02446             xst_left_shift_assignment_policy<
02447                 1, // xst_scalar capacity
02448                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02449                 primitive_id_unary_adaptor
02450             >
02451         > xst_adaptor_T;
02452 
02453         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
02454         return xst_adaptor_T(
02455             *this,
02456             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
02457             );
02458     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >, xst_left_shift_assignment_policy< xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator<<= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &  lambda_  ) 

Lambda left shift assignment operator support.

Template Parameters:
LambdaLhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
LambdaRhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
BinaryPolicyAdaptorT specifies policy type of cttl_impl::xst_binary_adaptor.
Parameters:
lambda_ reference to lambda expression policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_left_shift_assignment_policy operator policy.

Definition at line 2397 of file xst_binary_adaptor.h.

02398     {
02399         typedef xst_binary_adaptor<
02400             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02401             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
02402             xst_left_shift_assignment_policy<
02403                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
02404                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02405                 primitive_id_unary_adaptor
02406             >
02407         > xst_adaptor_T;
02408 
02409         return xst_adaptor_T( *this, lambda_ );
02410     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >, xst_left_shift_assignment_policy< xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator<<= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &  lambda_  ) 

Lambda left shift assignment operator support.

Template Parameters:
LambdaT specifies type of lambda expression encapsulated by cttl_impl::xst_unary_adaptor.
PolicyAdaptorT specifies policy type of cttl_impl::xst_unary_adaptor.
Parameters:
lambda_ reference to right-hand-side lambda operand policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_left_shift_assignment_policy operator policy.

Definition at line 2348 of file xst_binary_adaptor.h.

02349     {
02350         typedef xst_binary_adaptor<
02351             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02352             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
02353             xst_left_shift_assignment_policy<
02354                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
02355                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02356                 primitive_id_unary_adaptor
02357             >
02358         > xst_adaptor_T;
02359 
02360         return xst_adaptor_T( *this, lambda_ );
02361     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< typename LambdaT::reference_T >, xst_left_shift_assignment_policy< LambdaT::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator<<= ( xst_lambda_wrap< LambdaT > const &  lambda_  ) 

Lambda left shift assignment operator support.

Template Parameters:
LambdaT specifies right-hand-side lambda primitive.
Parameters:
lambda_ reference to right-hand-side lambda operand.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_left_shift_assignment_policy operator policy.

Definition at line 2303 of file xst_binary_adaptor.h.

02304     {
02305         typedef xst_binary_adaptor<
02306             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02307             xst_lambda_wrap< typename LambdaT::reference_T >,
02308             xst_left_shift_assignment_policy<
02309                 LambdaT::capacity_,
02310                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02311                 primitive_id_unary_adaptor
02312             >
02313         > xst_adaptor_T;
02314 
02315         return xst_adaptor_T( *this, lambda_.make_reference() );
02316     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT& > >, xst_left_shift_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator<<= ( RhsValueT *  pvalue_  ) 

Lambda left shift assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of assignment.
Parameters:
pvalue_ pointer to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_left_shift_assignment_policy operator policy.

Definition at line 2256 of file xst_binary_adaptor.h.

02257     {
02258         typedef xst_binary_adaptor<
02259             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02260             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02261             xst_left_shift_assignment_policy<
02262                 1, // xst_scalar capacity
02263                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02264                 primitive_id_unary_adaptor
02265             >
02266         > xst_adaptor_T;
02267 
02268         return xst_adaptor_T(
02269             *this,
02270             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
02271             );
02272     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT > >, xst_left_shift_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator<<= ( RhsValueT const &  value_  ) 

Lambda left shift assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of the operator expression.
Parameters:
value_ reference to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_left_shift_assignment_policy operator policy.

Definition at line 2213 of file xst_binary_adaptor.h.

02214     {
02215         typedef xst_binary_adaptor<
02216             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02217             xst_lambda_wrap< xst_scalar< RhsValueT > >,
02218             xst_left_shift_assignment_policy<
02219                 1, // xst_scalar capacity
02220                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02221                 primitive_id_unary_adaptor
02222             >
02223         > xst_adaptor_T;
02224 
02225         return xst_adaptor_T(
02226             *this,
02227             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
02228             );
02229     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >, xst_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator= ( std::stack< StackValueT > *  pstack_  ) 

Lambda assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
pstack_ pointer to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_assignment_policy operator policy.

Definition at line 518 of file xst_binary_adaptor.h.

00519     {
00520         typedef xst_binary_adaptor<
00521             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00522             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
00523             xst_assignment_policy<
00524                 1, // xst_stack capacity
00525                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00526                 primitive_id_unary_adaptor
00527             >
00528         > xst_adaptor_T;
00529 
00530         return xst_adaptor_T(
00531             *this,
00532             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
00533             );
00534     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< StackValueT > >, xst_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator= ( std::stack< StackValueT > const &  stack_  ) 

Lambda assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
stack_ reference to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_assignment_policy operator policy.

Definition at line 473 of file xst_binary_adaptor.h.

00474     {
00475         typedef xst_binary_adaptor<
00476             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00477             xst_lambda_wrap< xst_scalar< StackValueT > >,
00478             xst_assignment_policy<
00479                 1, // xst_scalar capacity
00480                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00481                 primitive_id_unary_adaptor
00482             >
00483         > xst_adaptor_T;
00484 
00485         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
00486         return xst_adaptor_T(
00487             *this,
00488             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
00489             );
00490     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >, xst_assignment_policy< xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &  lambda_  ) 

Lambda assignment operator support.

Template Parameters:
LambdaLhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
LambdaRhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
BinaryPolicyAdaptorT specifies policy type of cttl_impl::xst_binary_adaptor.
Parameters:
lambda_ reference to lambda expression policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_assignment_policy operator policy.

Definition at line 429 of file xst_binary_adaptor.h.

00430     {
00431         typedef xst_binary_adaptor<
00432             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00433             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
00434             xst_assignment_policy<
00435                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
00436                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00437                 primitive_id_unary_adaptor
00438             >
00439         > xst_adaptor_T;
00440 
00441         return xst_adaptor_T( *this, lambda_ );
00442     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >, xst_assignment_policy< xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &  lambda_  ) 

Lambda assignment operator support.

Template Parameters:
LambdaT specifies type of lambda expression encapsulated by cttl_impl::xst_unary_adaptor.
PolicyAdaptorT specifies policy type of cttl_impl::xst_unary_adaptor.
Parameters:
lambda_ reference to right-hand-side lambda operand policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_assignment_policy operator policy.

Definition at line 380 of file xst_binary_adaptor.h.

00381     {
00382         typedef xst_binary_adaptor<
00383             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00384             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
00385             xst_assignment_policy<
00386                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
00387                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00388                 primitive_id_unary_adaptor
00389             >
00390         > xst_adaptor_T;
00391 
00392         return xst_adaptor_T( *this, lambda_ );
00393     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< typename LambdaT::reference_T >, xst_assignment_policy< LambdaT::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator= ( xst_lambda_wrap< LambdaT > const &  lambda_  ) 

Lambda assignment operator support.

Template Parameters:
LambdaT specifies right-hand-side lambda primitive.
Parameters:
lambda_ reference to right-hand-side lambda operand.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_assignment_policy operator policy.

Definition at line 335 of file xst_binary_adaptor.h.

00336     {
00337         typedef xst_binary_adaptor<
00338             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00339             xst_lambda_wrap< typename LambdaT::reference_T >,
00340             xst_assignment_policy<
00341                 LambdaT::capacity_,
00342                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00343                 primitive_id_unary_adaptor
00344             >
00345         > xst_adaptor_T;
00346 
00347         return xst_adaptor_T( *this, lambda_.make_reference() );
00348     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT& > >, xst_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator= ( RhsValueT *  pvalue_  ) 

Lambda assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of assignment.
Parameters:
pvalue_ pointer to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_assignment_policy operator policy.

Definition at line 288 of file xst_binary_adaptor.h.

00289     {
00290         typedef xst_binary_adaptor<
00291             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00292             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
00293             xst_assignment_policy<
00294                 1, // xst_scalar capacity
00295                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00296                 primitive_id_unary_adaptor
00297             >
00298         > xst_adaptor_T;
00299 
00300         return xst_adaptor_T(
00301             *this,
00302             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
00303             );
00304     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT > >, xst_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator= ( RhsValueT const &  value_  ) 

Lambda assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of the operator expression.
Parameters:
value_ reference to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_assignment_policy operator policy.

Definition at line 245 of file xst_binary_adaptor.h.

00246     {
00247         typedef xst_binary_adaptor<
00248             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00249             xst_lambda_wrap< xst_scalar< RhsValueT > >,
00250             xst_assignment_policy<
00251                 1, // xst_scalar capacity
00252                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00253                 primitive_id_unary_adaptor
00254             >
00255         > xst_adaptor_T;
00256 
00257         return xst_adaptor_T(
00258             *this,
00259             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
00260             );
00261     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >, xst_right_shift_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator>>= ( std::stack< StackValueT > *  pstack_  ) 

Lambda right shift assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
pstack_ pointer to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_right_shift_assignment_policy operator policy.

Definition at line 2814 of file xst_binary_adaptor.h.

02815     {
02816         typedef xst_binary_adaptor<
02817             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02818             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02819             xst_right_shift_assignment_policy<
02820                 1, // xst_stack capacity
02821                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02822                 primitive_id_unary_adaptor
02823             >
02824         > xst_adaptor_T;
02825 
02826         return xst_adaptor_T(
02827             *this,
02828             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
02829             );
02830     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< StackValueT > >, xst_right_shift_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator>>= ( std::stack< StackValueT > const &  stack_  ) 

Lambda right shift assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
stack_ reference to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_right_shift_assignment_policy operator policy.

Definition at line 2769 of file xst_binary_adaptor.h.

02770     {
02771         typedef xst_binary_adaptor<
02772             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02773             xst_lambda_wrap< xst_scalar< StackValueT > >,
02774             xst_right_shift_assignment_policy<
02775                 1, // xst_scalar capacity
02776                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02777                 primitive_id_unary_adaptor
02778             >
02779         > xst_adaptor_T;
02780 
02781         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
02782         return xst_adaptor_T(
02783             *this,
02784             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
02785             );
02786     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >, xst_right_shift_assignment_policy< xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator>>= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &  lambda_  ) 

Lambda right shift assignment operator support.

Template Parameters:
LambdaLhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
LambdaRhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
BinaryPolicyAdaptorT specifies policy type of cttl_impl::xst_binary_adaptor.
Parameters:
lambda_ reference to lambda expression policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_right_shift_assignment_policy operator policy.

Definition at line 2725 of file xst_binary_adaptor.h.

02726     {
02727         typedef xst_binary_adaptor<
02728             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02729             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
02730             xst_right_shift_assignment_policy<
02731                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
02732                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02733                 primitive_id_unary_adaptor
02734             >
02735         > xst_adaptor_T;
02736 
02737         return xst_adaptor_T( *this, lambda_ );
02738     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >, xst_right_shift_assignment_policy< xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator>>= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &  lambda_  ) 

Lambda right shift assignment operator support.

Template Parameters:
LambdaT specifies type of lambda expression encapsulated by cttl_impl::xst_unary_adaptor.
PolicyAdaptorT specifies policy type of cttl_impl::xst_unary_adaptor.
Parameters:
lambda_ reference to right-hand-side lambda operand policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_right_shift_assignment_policy operator policy.

Definition at line 2676 of file xst_binary_adaptor.h.

02677     {
02678         typedef xst_binary_adaptor<
02679             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02680             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
02681             xst_right_shift_assignment_policy<
02682                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
02683                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02684                 primitive_id_unary_adaptor
02685             >
02686         > xst_adaptor_T;
02687 
02688         return xst_adaptor_T( *this, lambda_ );
02689     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< typename LambdaT::reference_T >, xst_right_shift_assignment_policy< LambdaT::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator>>= ( xst_lambda_wrap< LambdaT > const &  lambda_  ) 

Lambda right shift assignment operator support.

Template Parameters:
LambdaT specifies right-hand-side lambda primitive.
Parameters:
lambda_ reference to right-hand-side lambda operand.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_right_shift_assignment_policy operator policy.

Definition at line 2631 of file xst_binary_adaptor.h.

02632     {
02633         typedef xst_binary_adaptor<
02634             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02635             xst_lambda_wrap< typename LambdaT::reference_T >,
02636             xst_right_shift_assignment_policy<
02637                 LambdaT::capacity_,
02638                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02639                 primitive_id_unary_adaptor
02640             >
02641         > xst_adaptor_T;
02642 
02643         return xst_adaptor_T( *this, lambda_.make_reference() );
02644     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT& > >, xst_right_shift_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator>>= ( RhsValueT *  pvalue_  ) 

Lambda right shift assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of assignment.
Parameters:
pvalue_ pointer to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_right_shift_assignment_policy operator policy.

Definition at line 2584 of file xst_binary_adaptor.h.

02585     {
02586         typedef xst_binary_adaptor<
02587             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02588             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02589             xst_right_shift_assignment_policy<
02590                 1, // xst_scalar capacity
02591                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02592                 primitive_id_unary_adaptor
02593             >
02594         > xst_adaptor_T;
02595 
02596         return xst_adaptor_T(
02597             *this,
02598             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
02599             );
02600     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT > >, xst_right_shift_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator>>= ( RhsValueT const &  value_  ) 

Lambda right shift assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of the operator expression.
Parameters:
value_ reference to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_right_shift_assignment_policy operator policy.

Definition at line 2541 of file xst_binary_adaptor.h.

02542     {
02543         typedef xst_binary_adaptor<
02544             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02545             xst_lambda_wrap< xst_scalar< RhsValueT > >,
02546             xst_right_shift_assignment_policy<
02547                 1, // xst_scalar capacity
02548                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02549                 primitive_id_unary_adaptor
02550             >
02551         > xst_adaptor_T;
02552 
02553         return xst_adaptor_T(
02554             *this,
02555             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
02556             );
02557     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >, xst_bitwise_xor_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator^= ( std::stack< StackValueT > *  pstack_  ) 

Lambda bitwise exclusive or assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
pstack_ pointer to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_xor_assignment_policy operator policy.

Definition at line 3798 of file xst_binary_adaptor.h.

03799     {
03800         typedef xst_binary_adaptor<
03801             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03802             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03803             xst_bitwise_xor_assignment_policy<
03804                 1, // xst_stack capacity
03805                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03806                 primitive_id_unary_adaptor
03807             >
03808         > xst_adaptor_T;
03809 
03810         return xst_adaptor_T(
03811             *this,
03812             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
03813             );
03814     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< StackValueT > >, xst_bitwise_xor_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator^= ( std::stack< StackValueT > const &  stack_  ) 

Lambda bitwise exclusive or assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
stack_ reference to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_xor_assignment_policy operator policy.

Definition at line 3753 of file xst_binary_adaptor.h.

03754     {
03755         typedef xst_binary_adaptor<
03756             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03757             xst_lambda_wrap< xst_scalar< StackValueT > >,
03758             xst_bitwise_xor_assignment_policy<
03759                 1, // xst_scalar capacity
03760                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03761                 primitive_id_unary_adaptor
03762             >
03763         > xst_adaptor_T;
03764 
03765         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
03766         return xst_adaptor_T(
03767             *this,
03768             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
03769             );
03770     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >, xst_bitwise_xor_assignment_policy< xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator^= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &  lambda_  ) 

Lambda bitwise exclusive or assignment operator support.

Template Parameters:
LambdaLhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
LambdaRhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
BinaryPolicyAdaptorT specifies policy type of cttl_impl::xst_binary_adaptor.
Parameters:
lambda_ reference to lambda expression policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_xor_assignment_policy operator policy.

Definition at line 3709 of file xst_binary_adaptor.h.

03710     {
03711         typedef xst_binary_adaptor<
03712             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03713             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
03714             xst_bitwise_xor_assignment_policy<
03715                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
03716                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03717                 primitive_id_unary_adaptor
03718             >
03719         > xst_adaptor_T;
03720 
03721         return xst_adaptor_T( *this, lambda_ );
03722     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >, xst_bitwise_xor_assignment_policy< xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator^= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &  lambda_  ) 

Lambda bitwise exclusive or assignment operator support.

Template Parameters:
LambdaT specifies type of lambda expression encapsulated by cttl_impl::xst_unary_adaptor.
PolicyAdaptorT specifies policy type of cttl_impl::xst_unary_adaptor.
Parameters:
lambda_ reference to right-hand-side lambda operand policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_xor_assignment_policy operator policy.

Definition at line 3660 of file xst_binary_adaptor.h.

03661     {
03662         typedef xst_binary_adaptor<
03663             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03664             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
03665             xst_bitwise_xor_assignment_policy<
03666                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
03667                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03668                 primitive_id_unary_adaptor
03669             >
03670         > xst_adaptor_T;
03671 
03672         return xst_adaptor_T( *this, lambda_ );
03673     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< typename LambdaT::reference_T >, xst_bitwise_xor_assignment_policy< LambdaT::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator^= ( xst_lambda_wrap< LambdaT > const &  lambda_  ) 

Lambda bitwise exclusive or assignment operator support.

Template Parameters:
LambdaT specifies right-hand-side lambda primitive.
Parameters:
lambda_ reference to right-hand-side lambda operand.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_xor_assignment_policy operator policy.

Definition at line 3615 of file xst_binary_adaptor.h.

03616     {
03617         typedef xst_binary_adaptor<
03618             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03619             xst_lambda_wrap< typename LambdaT::reference_T >,
03620             xst_bitwise_xor_assignment_policy<
03621                 LambdaT::capacity_,
03622                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03623                 primitive_id_unary_adaptor
03624             >
03625         > xst_adaptor_T;
03626 
03627         return xst_adaptor_T( *this, lambda_.make_reference() );
03628     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT& > >, xst_bitwise_xor_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator^= ( RhsValueT *  pvalue_  ) 

Lambda bitwise exclusive or assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of assignment.
Parameters:
pvalue_ pointer to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_xor_assignment_policy operator policy.

Definition at line 3568 of file xst_binary_adaptor.h.

03569     {
03570         typedef xst_binary_adaptor<
03571             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03572             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
03573             xst_bitwise_xor_assignment_policy<
03574                 1, // xst_scalar capacity
03575                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03576                 primitive_id_unary_adaptor
03577             >
03578         > xst_adaptor_T;
03579 
03580         return xst_adaptor_T(
03581             *this,
03582             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
03583             );
03584     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT > >, xst_bitwise_xor_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator^= ( RhsValueT const &  value_  ) 

Lambda bitwise exclusive or assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of the operator expression.
Parameters:
value_ reference to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_xor_assignment_policy operator policy.

Definition at line 3525 of file xst_binary_adaptor.h.

03526     {
03527         typedef xst_binary_adaptor<
03528             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03529             xst_lambda_wrap< xst_scalar< RhsValueT > >,
03530             xst_bitwise_xor_assignment_policy<
03531                 1, // xst_scalar capacity
03532                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03533                 primitive_id_unary_adaptor
03534             >
03535         > xst_adaptor_T;
03536 
03537         return xst_adaptor_T(
03538             *this,
03539             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
03540             );
03541     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >, xst_bitwise_ior_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator|= ( std::stack< StackValueT > *  pstack_  ) 

Lambda bitwise inclusive or assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
pstack_ pointer to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_ior_assignment_policy operator policy.

Definition at line 3470 of file xst_binary_adaptor.h.

03471     {
03472         typedef xst_binary_adaptor<
03473             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03474             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03475             xst_bitwise_ior_assignment_policy<
03476                 1, // xst_stack capacity
03477                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03478                 primitive_id_unary_adaptor
03479             >
03480         > xst_adaptor_T;
03481 
03482         return xst_adaptor_T(
03483             *this,
03484             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
03485             );
03486     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename StackValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< StackValueT > >, xst_bitwise_ior_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator|= ( std::stack< StackValueT > const &  stack_  ) 

Lambda bitwise inclusive or assignment operator support.

Template Parameters:
StackValueT specifies value type of stack.
Parameters:
stack_ reference to stack.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_ior_assignment_policy operator policy.

Definition at line 3425 of file xst_binary_adaptor.h.

03426     {
03427         typedef xst_binary_adaptor<
03428             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03429             xst_lambda_wrap< xst_scalar< StackValueT > >,
03430             xst_bitwise_ior_assignment_policy<
03431                 1, // xst_scalar capacity
03432                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03433                 primitive_id_unary_adaptor
03434             >
03435         > xst_adaptor_T;
03436 
03437         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
03438         return xst_adaptor_T(
03439             *this,
03440             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
03441             );
03442     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaLhsT , typename LambdaRhsT , typename BinaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >, xst_bitwise_ior_assignment_policy< xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator|= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const &  lambda_  ) 

Lambda bitwise inclusive or assignment operator support.

Template Parameters:
LambdaLhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
LambdaRhsT specifies type of lambda expression encapsulated by cttl_impl::xst_binary_adaptor.
BinaryPolicyAdaptorT specifies policy type of cttl_impl::xst_binary_adaptor.
Parameters:
lambda_ reference to lambda expression policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_ior_assignment_policy operator policy.

Definition at line 3381 of file xst_binary_adaptor.h.

03382     {
03383         typedef xst_binary_adaptor<
03384             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03385             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
03386             xst_bitwise_ior_assignment_policy<
03387                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
03388                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03389                 primitive_id_unary_adaptor
03390             >
03391         > xst_adaptor_T;
03392 
03393         return xst_adaptor_T( *this, lambda_ );
03394     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT , typename UnaryPolicyAdaptorT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >, xst_bitwise_ior_assignment_policy< xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator|= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const &  lambda_  ) 

Lambda bitwise inclusive or assignment operator support.

Template Parameters:
LambdaT specifies type of lambda expression encapsulated by cttl_impl::xst_unary_adaptor.
PolicyAdaptorT specifies policy type of cttl_impl::xst_unary_adaptor.
Parameters:
lambda_ reference to right-hand-side lambda operand policy instance.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_ior_assignment_policy operator policy.

Definition at line 3332 of file xst_binary_adaptor.h.

03333     {
03334         typedef xst_binary_adaptor<
03335             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03336             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
03337             xst_bitwise_ior_assignment_policy<
03338                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
03339                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03340                 primitive_id_unary_adaptor
03341             >
03342         > xst_adaptor_T;
03343 
03344         return xst_adaptor_T( *this, lambda_ );
03345     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename LambdaT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< typename LambdaT::reference_T >, xst_bitwise_ior_assignment_policy< LambdaT::capacity_, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator|= ( xst_lambda_wrap< LambdaT > const &  lambda_  ) 

Lambda bitwise inclusive or assignment operator support.

Template Parameters:
LambdaT specifies right-hand-side lambda primitive.
Parameters:
lambda_ reference to right-hand-side lambda operand.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_ior_assignment_policy operator policy.

Definition at line 3287 of file xst_binary_adaptor.h.

03288     {
03289         typedef xst_binary_adaptor<
03290             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03291             xst_lambda_wrap< typename LambdaT::reference_T >,
03292             xst_bitwise_ior_assignment_policy<
03293                 LambdaT::capacity_,
03294                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03295                 primitive_id_unary_adaptor
03296             >
03297         > xst_adaptor_T;
03298 
03299         return xst_adaptor_T( *this, lambda_.make_reference() );
03300     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT& > >, xst_bitwise_ior_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator|= ( RhsValueT *  pvalue_  ) 

Lambda bitwise inclusive or assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of assignment.
Parameters:
pvalue_ pointer to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_ior_assignment_policy operator policy.

Definition at line 3240 of file xst_binary_adaptor.h.

03241     {
03242         typedef xst_binary_adaptor<
03243             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03244             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
03245             xst_bitwise_ior_assignment_policy<
03246                 1, // xst_scalar capacity
03247                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03248                 primitive_id_unary_adaptor
03249             >
03250         > xst_adaptor_T;
03251 
03252         return xst_adaptor_T(
03253             *this,
03254             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
03255             );
03256     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename RhsValueT >
xst_binary_adaptor< xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >, xst_lambda_wrap< xst_scalar< RhsValueT > >, xst_bitwise_ior_assignment_policy< 1, xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_, primitive_id_unary_adaptor > > cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::operator|= ( RhsValueT const &  value_  ) 

Lambda bitwise inclusive or assignment operator support.

Template Parameters:
RhsValueT specifies right-hand-side type of the operator expression.
Parameters:
value_ reference to right-hand-side value.
Returns:
Instance of lambda expression policy cttl_impl::xst_binary_adaptor, parameterized by cttl_impl::xst_bitwise_ior_assignment_policy operator policy.

Definition at line 3197 of file xst_binary_adaptor.h.

03198     {
03199         typedef xst_binary_adaptor<
03200             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03201             xst_lambda_wrap< xst_scalar< RhsValueT > >,
03202             xst_bitwise_ior_assignment_policy<
03203                 1, // xst_scalar capacity
03204                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03205                 primitive_id_unary_adaptor
03206             >
03207         > xst_adaptor_T;
03208 
03209         return xst_adaptor_T(
03210             *this,
03211             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
03212             );
03213     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
void cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::postfix_side_effects (  ) 

Fulfills postfix side effects for encapsulated lambda expresion.

Definition at line 196 of file xst_binary_adaptor.h.

00197     {
00198         PolicyAdaptorT::postfix_side_effects( this->m_expr_lhs );
00199     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
void cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::prefix_side_effects (  ) 

Fulfills prefix side effects for encapsulated lambda expresion.

Definition at line 190 of file xst_binary_adaptor.h.

00191     {
00192         PolicyAdaptorT::prefix_side_effects( this->m_expr_lhs, this->m_expr_rhs );
00193     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename SubscriptLambdaT >
value_T& cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::top ( SubscriptLambdaT   ) 

Evaluates encapsulated lambda expression and returns reference to the result.

Definition at line 175 of file xst_binary_adaptor.h.

00176     {
00177         prefix_side_effects();
00178         value_T& tmp_value_ref = lvalue_ref();
00179         postfix_side_effects();
00180         return tmp_value_ref;
00181     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
template<typename SubscriptLambdaT >
value_T cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::top ( SubscriptLambdaT   )  const

Evaluates encapsulated lambda expression and returns its result.

Definition at line 168 of file xst_binary_adaptor.h.

00169     {
00170         return top();
00171     }

template<typename LhsT, typename RhsT, typename PolicyAdaptorT>
value_T cttl_impl::xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::top (  )  const

Evaluates encapsulated lambda expression and returns its result.

Definition at line 161 of file xst_binary_adaptor.h.

00162     {
00163         return PolicyAdaptorT::top( this->m_expr_lhs, this->m_expr_rhs );
00164     }

The documentation for this class was generated from the following file:
Generated on Sun Aug 23 13:44:13 2009 for Common Text Transformation Library by  doxygen 1.5.9