logo top
Main Page   Groups   Namespaces  

operator.h File Reference


Namespaces

namespace  sigc

Classes

struct  sigc::dereference_trait<T_type>
 Deduces the base type of a reference or a pointer. More...
struct  sigc::dereference_trait<T_type*>
struct  sigc::dereference_trait<const T_type*>
struct  sigc::dereference_trait<T_type*&>
struct  sigc::dereference_trait<const T_type*&>
struct  sigc::dereference_trait<T_type* const&>
struct  sigc::dereference_trait<const T_type* const&>
struct  sigc::arithmetic<T_type>
struct  sigc::bitwise<T_type>
struct  sigc::logical<T_type>
struct  sigc::relational<T_type>
struct  sigc::arithmetic_assign<T_type>
struct  sigc::bitwise_assign<T_type>
struct  sigc::other<T_type>
struct  sigc::unary_arithmetic<T_type>
struct  sigc::unary_bitwise<T_type>
struct  sigc::unary_logical<T_type>
struct  sigc::unary_other<T_type>
struct  sigc::cast_<T_type>
struct  sigc::plus
struct  sigc::minus
struct  sigc::multiplies
struct  sigc::divides
struct  sigc::modulus
struct  sigc::leftshift
struct  sigc::rightshift
struct  sigc::and_
struct  sigc::or_
struct  sigc::xor_
struct  sigc::less
struct  sigc::greater
struct  sigc::less_equal
struct  sigc::greater_equal
struct  sigc::equal_to
struct  sigc::not_equal_to
struct  sigc::subscript
struct  sigc::assign
struct  sigc::pre_increment
struct  sigc::pre_decrement
struct  sigc::negate
struct  sigc::not_
struct  sigc::address
struct  sigc::dereference
struct  sigc::reinterpret_
struct  sigc::static_
struct  sigc::dynamic_
struct  sigc::lambda_action_deduce_result_type<T_action, T_test1, T_test2>
struct  sigc::lambda_action_deduce_result_type<logical<T_action>, T_test1, T_test2>
struct  sigc::lambda_action_deduce_result_type<relational<T_action>, T_test1, T_test2>
struct  sigc::lambda_action_deduce_result_type<arithmetic_assign<T_action>, T_test1, T_test2>
struct  sigc::lambda_action_deduce_result_type<bitwise_assign<T_action>, T_test1, T_test2>
struct  sigc::lambda_action_deduce_result_type<other<subscript>, T_test1, T_test2>
struct  sigc::lambda_action_unary_deduce_result_type<T_action, T_test>
struct  sigc::lambda_action_convert_deduce_result_type<T_action, T_type, T_test>
struct  sigc::lambda_action_unary_deduce_result_type<unary_logical<T_action>, T_test>
struct  sigc::lambda_action_unary_deduce_result_type<unary_other<address>, T_test>
struct  sigc::lambda_action_unary_deduce_result_type<unary_other<dereference>, T_test>
struct  sigc::lambda_action<T_action>
struct  sigc::lambda_action_unary<T_action>
struct  sigc::lambda_action_convert<T_action, T_type>
struct  sigc::lambda_action<arithmetic<plus>>
struct  sigc::lambda_action<arithmetic<minus>>
struct  sigc::lambda_action<arithmetic<multiplies>>
struct  sigc::lambda_action<arithmetic<divides>>
struct  sigc::lambda_action<arithmetic<modulus>>
struct  sigc::lambda_action<bitwise<leftshift>>
struct  sigc::lambda_action<bitwise<rightshift>>
struct  sigc::lambda_action<bitwise<and_>>
struct  sigc::lambda_action<bitwise<or_>>
struct  sigc::lambda_action<bitwise<xor_>>
struct  sigc::lambda_action<logical<and_>>
struct  sigc::lambda_action<logical<or_>>
struct  sigc::lambda_action<relational<less>>
struct  sigc::lambda_action<relational<greater>>
struct  sigc::lambda_action<relational<less_equal>>
struct  sigc::lambda_action<relational<greater_equal>>
struct  sigc::lambda_action<relational<equal_to>>
struct  sigc::lambda_action<relational<not_equal_to>>
struct  sigc::lambda_action<arithmetic_assign<plus>>
struct  sigc::lambda_action<arithmetic_assign<minus>>
struct  sigc::lambda_action<arithmetic_assign<multiplies>>
struct  sigc::lambda_action<arithmetic_assign<divides>>
struct  sigc::lambda_action<arithmetic_assign<modulus>>
struct  sigc::lambda_action<bitwise_assign<leftshift>>
struct  sigc::lambda_action<bitwise_assign<rightshift>>
struct  sigc::lambda_action<bitwise_assign<and_>>
struct  sigc::lambda_action<bitwise_assign<or_>>
struct  sigc::lambda_action<bitwise_assign<xor_>>
struct  sigc::lambda_action<other<subscript>>
struct  sigc::lambda_action<other<assign>>
struct  sigc::lambda_action_unary<unary_arithmetic<pre_increment>>
struct  sigc::lambda_action_unary<unary_arithmetic<pre_decrement>>
struct  sigc::lambda_action_unary<unary_arithmetic<negate>>
struct  sigc::lambda_action_unary<unary_bitwise<not_>>
struct  sigc::lambda_action_unary<unary_logical<not_>>
struct  sigc::lambda_action_unary<unary_other<address>>
struct  sigc::lambda_action_unary<unary_other<dereference>>
struct  sigc::lambda_action_convert<cast_<reinterpret_>, T_type>
struct  sigc::lambda_action_convert<cast_<static_>, T_type>
struct  sigc::lambda_action_convert<cast_<dynamic_>, T_type>
struct  sigc::lambda_operator<T_action, T_type1, T_type2>
struct  sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::lambda_operator_unary<T_action, T_type>
struct  sigc::lambda_operator_unary<T_action, T_type>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::lambda_operator_convert<T_action, T_type, T_arg>
struct  sigc::lambda_operator_convert<T_action, T_type, T_arg>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>

Functions

template<class T_action, class T_lambda_action, class T_arg1, class T_arg2>
void visit_each (const T_action& _A_action, const lambda_operator<T_lambda_action, T_arg1, T_arg2 >& _A_target)
template<class T_action, class T_lambda_action, class T_arg>
void visit_each (const T_action& _A_action, const lambda_operator_unary<T_lambda_action, T_arg>& _A_target)
template<class T_action, class T_lambda_action, class T_type, class T_arg>
void visit_each (const T_action& _A_action, const lambda_operator_convert<T_lambda_action, T_type, T_arg>& _A_target)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic<
plus >, T_arg1, T_arg2 > > 
operator+ (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic<
plus >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator+ (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic<
plus >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator+ (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic<
minus >, T_arg1, T_arg2 > > 
operator- (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic<
minus >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator- (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic<
minus >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator- (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic<
multiplies >, T_arg1, T_arg2 > > 
operator* (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic<
multiplies >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator* (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic<
multiplies >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator* (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic<
divides >, T_arg1, T_arg2 > > 
operator/ (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic<
divides >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator/ (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic<
divides >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator/ (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic<
modulus >, T_arg1, T_arg2 > > 
operator% (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic<
modulus >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator% (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic<
modulus >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator% (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise<
leftshift >, T_arg1, T_arg2 > > 
operator<< (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise<
leftshift >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator<< (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise<
leftshift >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator<< (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise<
rightshift >, T_arg1, T_arg2 > > 
operator>> (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise<
rightshift >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator>> (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise<
rightshift >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator>> (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise<
and_ >, T_arg1, T_arg2 > > 
operator& (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise<
and_ >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator& (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise<
and_ >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator& (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise<
or_ >, T_arg1, T_arg2 > > 
operator| (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise<
or_ >, T_arg1, typename unwrap_reference<
T_arg2 >::type > > 
operator| (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise<
or_ >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator| (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise<
xor_ >, T_arg1, T_arg2 > > 
operator^ (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise<
xor_ >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator^ (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise<
xor_ >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator^ (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<logical<
and_ >, T_arg1, T_arg2 > > 
operator&& (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<logical<
and_ >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator&& (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<logical<
and_ >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator&& (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<logical<
or_ >, T_arg1, T_arg2 > > 
operator|| (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<logical<
or_ >, T_arg1, typename unwrap_reference<
T_arg2 >::type > > 
operator|| (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<logical<
or_ >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator|| (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<relational<
less >, T_arg1, T_arg2 > > 
operator< (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<relational<
less >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator< (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<relational<
less >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator< (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<relational<
greater >, T_arg1, T_arg2 > > 
operator> (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<relational<
greater >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator> (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<relational<
greater >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator> (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<relational<
less_equal >, T_arg1, T_arg2 > > 
operator<= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<relational<
less_equal >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator<= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<relational<
less_equal >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator<= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<relational<
greater_equal >, T_arg1,
T_arg2 > > 
operator>= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<relational<
greater_equal >, T_arg1,
typename unwrap_reference<
T_arg2 >::type > > 
operator>= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<relational<
greater_equal >, typename
unwrap_reference< T_arg1
>::type, T_arg2 > > 
operator>= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<relational<
equal_to >, T_arg1, T_arg2 > > 
operator== (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<relational<
equal_to >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator== (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<relational<
equal_to >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator== (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<relational<
not_equal_to >, T_arg1, T_arg2 > > 
operator!= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<relational<
not_equal_to >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator!= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<relational<
not_equal_to >, typename
unwrap_reference< T_arg1
>::type, T_arg2 > > 
operator!= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic_assign<
plus >, T_arg1, T_arg2 > > 
operator+= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic_assign<
plus >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator+= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic_assign<
plus >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator+= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic_assign<
minus >, T_arg1, T_arg2 > > 
operator-= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic_assign<
minus >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator-= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic_assign<
minus >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator-= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic_assign<
multiplies >, T_arg1, T_arg2 > > 
operator*= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic_assign<
multiplies >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator*= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic_assign<
multiplies >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator*= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic_assign<
divides >, T_arg1, T_arg2 > > 
operator/= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic_assign<
divides >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator/= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic_assign<
divides >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator/= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic_assign<
modulus >, T_arg1, T_arg2 > > 
operator%= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic_assign<
modulus >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator%= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<arithmetic_assign<
modulus >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator%= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise_assign<
leftshift >, T_arg1, T_arg2 > > 
operator<<= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise_assign<
leftshift >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator<<= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise_assign<
leftshift >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator<<= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise_assign<
rightshift >, T_arg1, T_arg2 > > 
operator>>= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise_assign<
rightshift >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator>>= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise_assign<
rightshift >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator>>= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise_assign<
and_ >, T_arg1, T_arg2 > > 
operator&= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise_assign<
and_ >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator&= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise_assign<
and_ >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator&= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise_assign<
or_ >, T_arg1, T_arg2 > > 
operator|= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise_assign<
or_ >, T_arg1, typename unwrap_reference<
T_arg2 >::type > > 
operator|= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise_assign<
or_ >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator|= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise_assign<
xor_ >, T_arg1, T_arg2 > > 
operator^= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise_assign<
xor_ >, T_arg1, typename
unwrap_reference< T_arg2
>::type > > 
operator^= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda< lambda_operator<bitwise_assign<
xor_ >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator^= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg>
lambda< lambda_operator_unary<
unary_arithmetic< pre_increment >,
T_arg > > 
operator++ (const lambda<T_arg>& a)
template<class T_arg>
lambda< lambda_operator_unary<
unary_arithmetic< pre_decrement >,
T_arg > > 
operator-- (const lambda<T_arg>& a)
template<class T_arg>
lambda< lambda_operator_unary<
unary_arithmetic< negate >,
T_arg > > 
operator- (const lambda<T_arg>& a)
template<class T_arg>
lambda< lambda_operator_unary<
unary_bitwise<not_ >, T_arg >> 
operator~ (const lambda<T_arg>& a)
template<class T_arg>
lambda< lambda_operator_unary<
unary_logical<not_ >, T_arg >> 
operator! (const lambda<T_arg>& a)
template<class T_arg>
lambda< lambda_operator_unary<
unary_other<address >, T_arg >> 
operator& (const lambda<T_arg>& a)
template<class T_arg>
lambda< lambda_operator_unary<
unary_other< dereference >,
T_arg > > 
operator* (const lambda<T_arg>& a)
template<class T_type, class T_arg>
lambda< lambda_operator_convert<
cast_< reinterpret_ >, T_type,
typename unwrap_lambda_type<
T_arg >::type > > 
reinterpret_cast_ (const T_arg& a)
template<class T_type, class T_arg>
lambda< lambda_operator_convert<
cast_< static_ >, T_type,
typename unwrap_lambda_type<
T_arg >::type > > 
static_cast_ (const T_arg& a)
template<class T_type, class T_arg>
lambda< lambda_operator_convert<
cast_< dynamic_ >, T_type,
typename unwrap_lambda_type<
T_arg >::type > > 
dynamic_cast_ (const T_arg& a)

Function Documentation

template <class T_type, class T_arg>
lambda<lambda_operator_convert<cast_<dynamic_>, T_type, typename unwrap_lambda_type<T_arg>::type> > dynamic_cast_ ( const T_arg&  a  ) 
 

template <class T_arg>
lambda<lambda_operator_unary<unary_other<address>, T_arg> > operator& ( const lambda<T_arg>&  a  ) 
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise<and_>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator& ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise<and_>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator& ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise<and_>, T_arg1, T_arg2> > operator& ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<logical<and_>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator && ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<logical<and_>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator && ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<logical<and_>, T_arg1, T_arg2> > operator && ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise_assign<and_>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator &= ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise_assign<and_>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator &= ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise_assign<and_>, T_arg1, T_arg2> > operator &= ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg>
lambda<lambda_operator_unary<unary_other<dereference>, T_arg> > operator* ( const lambda<T_arg>&  a  ) 
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic<multiplies>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator* ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic<multiplies>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator* ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic<multiplies>, T_arg1, T_arg2> > operator* ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic_assign<multiplies>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator *= ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic_assign<multiplies>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator *= ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic_assign<multiplies>, T_arg1, T_arg2> > operator *= ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg>
lambda<lambda_operator_unary<unary_logical<not_>, T_arg> > operator! ( const lambda<T_arg>&  a  ) 
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<relational<not_equal_to>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator!= ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<relational<not_equal_to>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator!= ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<relational<not_equal_to>, T_arg1, T_arg2> > operator!= ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic<modulus>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator% ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic<modulus>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator% ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic<modulus>, T_arg1, T_arg2> > operator% ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic_assign<modulus>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator%= ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic_assign<modulus>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator%= ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic_assign<modulus>, T_arg1, T_arg2> > operator%= ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic<plus>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator+ ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic<plus>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator+ ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic<plus>, T_arg1, T_arg2> > operator+ ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg>
lambda<lambda_operator_unary<unary_arithmetic<pre_increment>, T_arg> > operator++ ( const lambda<T_arg>&  a  ) 
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic_assign<plus>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator+= ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic_assign<plus>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator+= ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic_assign<plus>, T_arg1, T_arg2> > operator+= ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg>
lambda<lambda_operator_unary<unary_arithmetic<negate>, T_arg> > operator- ( const lambda<T_arg>&  a  ) 
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic<minus>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator- ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic<minus>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator- ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic<minus>, T_arg1, T_arg2> > operator- ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg>
lambda<lambda_operator_unary<unary_arithmetic<pre_decrement>, T_arg> > operator-- ( const lambda<T_arg>&  a  ) 
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic_assign<minus>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator-= ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic_assign<minus>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator-= ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic_assign<minus>, T_arg1, T_arg2> > operator-= ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic<divides>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator/ ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic<divides>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator/ ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic<divides>, T_arg1, T_arg2> > operator/ ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic_assign<divides>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator/= ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic_assign<divides>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator/= ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<arithmetic_assign<divides>, T_arg1, T_arg2> > operator/= ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<relational<less>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator< ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<relational<less>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator< ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<relational<less>, T_arg1, T_arg2> > operator< ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise<leftshift>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator<< ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise<leftshift>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator<< ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise<leftshift>, T_arg1, T_arg2> > operator<< ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise_assign<leftshift>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator<<= ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise_assign<leftshift>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator<<= ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise_assign<leftshift>, T_arg1, T_arg2> > operator<<= ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<relational<less_equal>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator<= ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<relational<less_equal>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator<= ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<relational<less_equal>, T_arg1, T_arg2> > operator<= ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<relational<equal_to>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator== ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<relational<equal_to>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator== ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<relational<equal_to>, T_arg1, T_arg2> > operator== ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<relational<greater>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator> ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<relational<greater>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator> ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<relational<greater>, T_arg1, T_arg2> > operator> ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<relational<greater_equal>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator>= ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<relational<greater_equal>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator>= ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<relational<greater_equal>, T_arg1, T_arg2> > operator>= ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise<rightshift>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator>> ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise<rightshift>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator>> ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise<rightshift>, T_arg1, T_arg2> > operator>> ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise_assign<rightshift>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator>>= ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise_assign<rightshift>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator>>= ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise_assign<rightshift>, T_arg1, T_arg2> > operator>>= ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise<xor_>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator^ ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise<xor_>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator^ ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise<xor_>, T_arg1, T_arg2> > operator^ ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise_assign<xor_>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator^= ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise_assign<xor_>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator^= ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise_assign<xor_>, T_arg1, T_arg2> > operator^= ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise<or_>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator| ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise<or_>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator| ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise<or_>, T_arg1, T_arg2> > operator| ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise_assign<or_>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator|= ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise_assign<or_>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator|= ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<bitwise_assign<or_>, T_arg1, T_arg2> > operator|= ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<logical<or_>, typename unwrap_reference<T_arg1>::type, T_arg2> > operator|| ( const T_arg1&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<logical<or_>, T_arg1, typename unwrap_reference<T_arg2>::type> > operator|| ( const lambda<T_arg1>&  a1,
const T_arg2&  a2
 

template <class T_arg1, class T_arg2>
lambda<lambda_operator<logical<or_>, T_arg1, T_arg2> > operator|| ( const lambda<T_arg1>&  a1,
const lambda<T_arg2>&  a2
 

template <class T_arg>
lambda<lambda_operator_unary<unary_bitwise<not_>, T_arg> > operator~ ( const lambda<T_arg>&  a  ) 
 

template <class T_type, class T_arg>
lambda<lambda_operator_convert<cast_<reinterpret_>, T_type, typename unwrap_lambda_type<T_arg>::type> > reinterpret_cast_ ( const T_arg&  a  ) 
 

template <class T_type, class T_arg>
lambda<lambda_operator_convert<cast_<static_>, T_type, typename unwrap_lambda_type<T_arg>::type> > static_cast_ ( const T_arg&  a  ) 
 

template <class T_action, class T_lambda_action, class T_type, class T_arg>
void visit_each ( const T_action&  _A_action,
const lambda_operator_convert<T_lambda_action, T_type, T_arg>&  _A_target
 

template <class T_action, class T_lambda_action, class T_arg>
void visit_each ( const T_action&  _A_action,
const lambda_operator_unary<T_lambda_action, T_arg>&  _A_target
 

template <class T_action, class T_lambda_action, class T_arg1, class T_arg2>
void visit_each ( const T_action&  _A_action,
const lambda_operator<T_lambda_action, T_arg1, T_arg2 >&  _A_target
 


Generated for libsigc++ 2.0 by Doxygen 1.3.9.1 © 1997-2001