libsigc++ 2.0: operator.h File Reference

Main Page Groups Namespaces

# operator.h File Reference

## Namespaces
namespace | sigc
## 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
| ) |