logo top
Main Page   Groups   Namespaces  

sigc Namespace Reference


Compounds

struct  adaptor_base
 A hint to the compiler. More...

struct  adaptor_functor
 Converts an arbitrary functor into an adaptor type. More...

struct  adaptor_functor.deduce_result_type
struct  adaptor_trait<T_functor, false>
 Trait that specifies what is the adaptor version of a functor type. More...

struct  adaptor_trait<T_functor, true>
 Trait that specifies what is the adaptor version of a functor type. More...

struct  adapts
 Base type for adaptors. More...

struct  address
struct  and_
struct  arithmetic
struct  arithmetic_assign
struct  assign
struct  bind_functor<0, T_functor, T_bound>
 Adaptor that binds an argument to the wrapped functor. More...

struct  bind_functor<0, T_functor, T_bound>.deduce_result_type
struct  bind_functor<1, T_functor, T_bound>
 Adaptor that binds an argument to the wrapped functor. More...

struct  bind_functor<1, T_functor, T_bound>.deduce_result_type
struct  bind_functor<2, T_functor, T_bound>
 Adaptor that binds an argument to the wrapped functor. More...

struct  bind_functor<2, T_functor, T_bound>.deduce_result_type
struct  bind_functor<3, T_functor, T_bound>
 Adaptor that binds an argument to the wrapped functor. More...

struct  bind_functor<3, T_functor, T_bound>.deduce_result_type
struct  bind_functor<4, T_functor, T_bound>
 Adaptor that binds an argument to the wrapped functor. More...

struct  bind_functor<4, T_functor, T_bound>.deduce_result_type
struct  bind_functor<5, T_functor, T_bound>
 Adaptor that binds an argument to the wrapped functor. More...

struct  bind_functor<5, T_functor, T_bound>.deduce_result_type
struct  bind_functor<6, T_functor, T_bound>
 Adaptor that binds an argument to the wrapped functor. More...

struct  bind_functor<6, T_functor, T_bound>.deduce_result_type
struct  bind_functor<-1, T_functor, T_type1 >
 Adaptor that binds 1 argument(s) to the wrapped functor. More...

struct  bind_functor<-1, T_functor, T_type1 >.deduce_result_type
struct  bind_functor<-1, T_functor, T_type1 >.deduce_result_type<T_arg1>
struct  bind_functor<-1, T_functor, T_type1 >.deduce_result_type<T_arg1, T_arg2>
struct  bind_functor<-1, T_functor, T_type1 >.deduce_result_type<T_arg1, T_arg2, T_arg3>
struct  bind_functor<-1, T_functor, T_type1 >.deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>
struct  bind_functor<-1, T_functor, T_type1 >.deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
struct  bind_functor<-1, T_functor, T_type1, T_type2 >
 Adaptor that binds 2 argument(s) to the wrapped functor. More...

struct  bind_functor<-1, T_functor, T_type1, T_type2 >.deduce_result_type
struct  bind_functor<-1, T_functor, T_type1, T_type2 >.deduce_result_type<T_arg1>
struct  bind_functor<-1, T_functor, T_type1, T_type2 >.deduce_result_type<T_arg1, T_arg2>
struct  bind_functor<-1, T_functor, T_type1, T_type2 >.deduce_result_type<T_arg1, T_arg2, T_arg3>
struct  bind_functor<-1, T_functor, T_type1, T_type2 >.deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>
struct  bind_functor<-1, T_functor, T_type1, T_type2, T_type3 >
 Adaptor that binds 3 argument(s) to the wrapped functor. More...

struct  bind_functor<-1, T_functor, T_type1, T_type2, T_type3 >.deduce_result_type
struct  bind_functor<-1, T_functor, T_type1, T_type2, T_type3 >.deduce_result_type<T_arg1>
struct  bind_functor<-1, T_functor, T_type1, T_type2, T_type3 >.deduce_result_type<T_arg1, T_arg2>
struct  bind_functor<-1, T_functor, T_type1, T_type2, T_type3 >.deduce_result_type<T_arg1, T_arg2, T_arg3>
struct  bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4 >
 Adaptor that binds 4 argument(s) to the wrapped functor. More...

struct  bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4 >.deduce_result_type
struct  bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4 >.deduce_result_type<T_arg1>
struct  bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4 >.deduce_result_type<T_arg1, T_arg2>
struct  bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5 >
 Adaptor that binds 5 argument(s) to the wrapped functor. More...

struct  bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5 >.deduce_result_type
struct  bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5 >.deduce_result_type<T_arg1>
struct  bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6 >
 Adaptor that binds 6 argument(s) to the wrapped functor. More...

struct  bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6 >.deduce_result_type
struct  bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >
 Adaptor that binds 7 argument(s) to the wrapped functor. More...

struct  bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >.deduce_result_type
struct  bind_return_functor
struct  bind_return_functor.deduce_result_type
struct  bitwise
struct  bitwise_assign
class  bound_const_mem_functor0
 bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance. More...

class  bound_const_mem_functor1
 bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance. More...

class  bound_const_mem_functor2
 bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance. More...

class  bound_const_mem_functor3
 bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance. More...

class  bound_const_mem_functor4
 bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance. More...

class  bound_const_mem_functor5
 bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance. More...

class  bound_const_mem_functor6
 bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance. More...

class  bound_const_mem_functor7
 bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance. More...

class  bound_const_volatile_mem_functor0
 bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object instance. More...

class  bound_const_volatile_mem_functor1
 bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object instance. More...

class  bound_const_volatile_mem_functor2
 bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object instance. More...

class  bound_const_volatile_mem_functor3
 bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object instance. More...

class  bound_const_volatile_mem_functor4
 bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object instance. More...

class  bound_const_volatile_mem_functor5
 bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object instance. More...

class  bound_const_volatile_mem_functor6
 bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object instance. More...

class  bound_const_volatile_mem_functor7
 bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object instance. More...

class  bound_mem_functor0
 bound_mem_functor0 encapsulates a method with 0 arguments and an object instance. More...

class  bound_mem_functor1
 bound_mem_functor1 encapsulates a method with 1 arguments and an object instance. More...

class  bound_mem_functor2
 bound_mem_functor2 encapsulates a method with 2 arguments and an object instance. More...

class  bound_mem_functor3
 bound_mem_functor3 encapsulates a method with 3 arguments and an object instance. More...

class  bound_mem_functor4
 bound_mem_functor4 encapsulates a method with 4 arguments and an object instance. More...

class  bound_mem_functor5
 bound_mem_functor5 encapsulates a method with 5 arguments and an object instance. More...

class  bound_mem_functor6
 bound_mem_functor6 encapsulates a method with 6 arguments and an object instance. More...

class  bound_mem_functor7
 bound_mem_functor7 encapsulates a method with 7 arguments and an object instance. More...

class  bound_volatile_mem_functor0
 bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance. More...

class  bound_volatile_mem_functor1
 bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance. More...

class  bound_volatile_mem_functor2
 bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance. More...

class  bound_volatile_mem_functor3
 bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance. More...

class  bound_volatile_mem_functor4
 bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance. More...

class  bound_volatile_mem_functor5
 bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance. More...

class  bound_volatile_mem_functor6
 bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance. More...

class  bound_volatile_mem_functor7
 bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance. More...

struct  cast_
struct  compose1_functor
struct  compose1_functor.deduce_result_type
struct  compose2_functor
struct  compose2_functor.deduce_result_type
struct  connection
 Convinience class for safe disconnection. More...

class  const_mem_functor0
 const_mem_functor0 wraps const methods with 0 argument(s). More...

class  const_mem_functor1
 const_mem_functor1 wraps const methods with 1 argument(s). More...

class  const_mem_functor2
 const_mem_functor2 wraps const methods with 2 argument(s). More...

class  const_mem_functor3
 const_mem_functor3 wraps const methods with 3 argument(s). More...

class  const_mem_functor4
 const_mem_functor4 wraps const methods with 4 argument(s). More...

class  const_mem_functor5
 const_mem_functor5 wraps const methods with 5 argument(s). More...

class  const_mem_functor6
 const_mem_functor6 wraps const methods with 6 argument(s). More...

class  const_mem_functor7
 const_mem_functor7 wraps const methods with 7 argument(s). More...

struct  const_reference_wrapper
class  const_volatile_mem_functor0
 const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s). More...

class  const_volatile_mem_functor1
 const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s). More...

class  const_volatile_mem_functor2
 const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s). More...

class  const_volatile_mem_functor3
 const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s). More...

class  const_volatile_mem_functor4
 const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s). More...

class  const_volatile_mem_functor5
 const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s). More...

class  const_volatile_mem_functor6
 const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s). More...

class  const_volatile_mem_functor7
 const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s). More...

struct  deduce_result_type
 Deduce the return type of a functor. More...

struct  deduce_result_type<T_functor, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, true>
 Deduce the return type of a functor. More...

struct  deduce_result_type<T_functor, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, void, true>
 Deduce the return type of a functor. More...

struct  deduce_result_type<T_functor, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, void, void, true>
 Deduce the return type of a functor. More...

struct  deduce_result_type<T_functor, T_arg1, T_arg2, T_arg3, T_arg4, void, void, void, true>
 Deduce the return type of a functor. More...

struct  deduce_result_type<T_functor, T_arg1, T_arg2, T_arg3, void, void, void, void, true>
 Deduce the return type of a functor. More...

struct  deduce_result_type<T_functor, T_arg1, T_arg2, void, void, void, void, void, true>
 Deduce the return type of a functor. More...

struct  deduce_result_type<T_functor, T_arg1, void, void, void, void, void, void, true>
 Deduce the return type of a functor. More...

struct  deduce_result_type<T_functor, void, void, void, void, void, void, void, true>
 Deduce the return type of a functor. More...

struct  dereference
struct  dereference_trait
struct  dereference_trait<const T_type*>
struct  dereference_trait<const T_type*&>
struct  dereference_trait<const T_type* const&>
struct  dereference_trait<T_type*>
struct  dereference_trait<T_type*&>
struct  dereference_trait<T_type* const&>
struct  divides
struct  dynamic_
struct  equal_to
struct  exception_catch_functor
struct  exception_catch_functor.deduce_result_type
struct  exception_catch_functor<T_functor, T_catcher, void>
struct  functor_base
 A hint to the compiler. More...

struct  functor_trait
struct  functor_trait<T_functor, true>
struct  functor_trait<T_return(*)(), false>
struct  functor_trait<T_return(*)(T_arg1), false>
struct  functor_trait<T_return(*)(T_arg1, T_arg2), false>
struct  functor_trait<T_return(*)(T_arg1, T_arg2, T_arg3), false>
struct  functor_trait<T_return(*)(T_arg1, T_arg2, T_arg3, T_arg4), false>
struct  functor_trait<T_return(*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5), false>
struct  functor_trait<T_return(*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6), false>
struct  functor_trait<T_return(*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7), false>
struct  functor_trait<T_return(T_obj.*)() const, false>
struct  functor_trait<T_return(T_obj.*)(), false>
struct  functor_trait<T_return(T_obj.*)(T_arg1) const, false>
struct  functor_trait<T_return(T_obj.*)(T_arg1), false>
struct  functor_trait<T_return(T_obj.*)(T_arg1, T_arg2) const, false>
struct  functor_trait<T_return(T_obj.*)(T_arg1, T_arg2), false>
struct  functor_trait<T_return(T_obj.*)(T_arg1, T_arg2, T_arg3) const, false>
struct  functor_trait<T_return(T_obj.*)(T_arg1, T_arg2, T_arg3), false>
struct  functor_trait<T_return(T_obj.*)(T_arg1, T_arg2, T_arg3, T_arg4) const, false>
struct  functor_trait<T_return(T_obj.*)(T_arg1, T_arg2, T_arg3, T_arg4), false>
struct  functor_trait<T_return(T_obj.*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const, false>
struct  functor_trait<T_return(T_obj.*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5), false>
struct  functor_trait<T_return(T_obj.*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const, false>
struct  functor_trait<T_return(T_obj.*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6), false>
struct  functor_trait<T_return(T_obj.*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const, false>
struct  functor_trait<T_return(T_obj.*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7), false>
struct  greater
struct  greater_equal
struct  hide_functor<0, T_functor>
 Adaptor that adds a dummy parameter to the wrapped functor. More...

struct  hide_functor<0, T_functor>.deduce_result_type
struct  hide_functor<1, T_functor>
 Adaptor that adds a dummy parameter to the wrapped functor. More...

struct  hide_functor<1, T_functor>.deduce_result_type
struct  hide_functor<2, T_functor>
 Adaptor that adds a dummy parameter to the wrapped functor. More...

struct  hide_functor<2, T_functor>.deduce_result_type
struct  hide_functor<3, T_functor>
 Adaptor that adds a dummy parameter to the wrapped functor. More...

struct  hide_functor<3, T_functor>.deduce_result_type
struct  hide_functor<4, T_functor>
 Adaptor that adds a dummy parameter to the wrapped functor. More...

struct  hide_functor<4, T_functor>.deduce_result_type
struct  hide_functor<5, T_functor>
 Adaptor that adds a dummy parameter to the wrapped functor. More...

struct  hide_functor<5, T_functor>.deduce_result_type
struct  hide_functor<6, T_functor>
 Adaptor that adds a dummy parameter to the wrapped functor. More...

struct  hide_functor<6, T_functor>.deduce_result_type
struct  hide_functor<-1, T_functor >
 Adaptor that adds a dummy parameter to the wrapped functor. More...

struct  hide_functor<-1, T_functor >.deduce_result_type
struct  is_base_and_derived
 From Esa Pulkkin: Compile-time determination of base-class relationship in C++ (adapted to match the syntax of boost's type_traits library). More...

struct  is_base_and_derived.big
struct  is_base_and_derived.test
struct  is_base_and_derived<T_base, T_base>
struct  lambda
struct  lambda_action
struct  lambda_action<arithmetic<divides>>
struct  lambda_action<arithmetic<minus>>
struct  lambda_action<arithmetic<modulus>>
struct  lambda_action<arithmetic<multiplies>>
struct  lambda_action<arithmetic<plus>>
struct  lambda_action<arithmetic_assign<divides>>
struct  lambda_action<arithmetic_assign<minus>>
struct  lambda_action<arithmetic_assign<modulus>>
struct  lambda_action<arithmetic_assign<multiplies>>
struct  lambda_action<arithmetic_assign<plus>>
struct  lambda_action<bitwise<and_>>
struct  lambda_action<bitwise<leftshift>>
struct  lambda_action<bitwise<or_>>
struct  lambda_action<bitwise<rightshift>>
struct  lambda_action<bitwise<xor_>>
struct  lambda_action<bitwise_assign<and_>>
struct  lambda_action<bitwise_assign<leftshift>>
struct  lambda_action<bitwise_assign<or_>>
struct  lambda_action<bitwise_assign<rightshift>>
struct  lambda_action<bitwise_assign<xor_>>
struct  lambda_action<logical<and_>>
struct  lambda_action<logical<or_>>
struct  lambda_action<other<assign>>
struct  lambda_action<other<subscript>>
struct  lambda_action<relational<equal_to>>
struct  lambda_action<relational<greater>>
struct  lambda_action<relational<greater_equal>>
struct  lambda_action<relational<less>>
struct  lambda_action<relational<less_equal>>
struct  lambda_action<relational<not_equal_to>>
struct  lambda_action_convert
struct  lambda_action_convert<cast_<dynamic_>, T_type>
struct  lambda_action_convert<cast_<reinterpret_>, T_type>
struct  lambda_action_convert<cast_<static_>, T_type>
struct  lambda_action_convert_deduce_result_type
struct  lambda_action_deduce_result_type
struct  lambda_action_deduce_result_type<arithmetic_assign<T_action>, T_test1, T_test2>
struct  lambda_action_deduce_result_type<bitwise_assign<T_action>, T_test1, T_test2>
struct  lambda_action_deduce_result_type<logical<T_action>, T_test1, T_test2>
struct  lambda_action_deduce_result_type<other<subscript>, T_test1, T_test2>
struct  lambda_action_deduce_result_type<relational<T_action>, T_test1, T_test2>
struct  lambda_action_unary
struct  lambda_action_unary<unary_arithmetic<negate>>
struct  lambda_action_unary<unary_arithmetic<pre_decrement>>
struct  lambda_action_unary<unary_arithmetic<pre_increment>>
struct  lambda_action_unary<unary_bitwise<not_>>
struct  lambda_action_unary<unary_logical<not_>>
struct  lambda_action_unary<unary_other<address>>
struct  lambda_action_unary<unary_other<dereference>>
struct  lambda_action_unary_deduce_result_type
struct  lambda_action_unary_deduce_result_type<unary_logical<T_action>, T_test>
struct  lambda_action_unary_deduce_result_type<unary_other<address>, T_test>
struct  lambda_action_unary_deduce_result_type<unary_other<dereference>, T_test>
struct  lambda_base
struct  lambda_group1
struct  lambda_group1.deduce_result_type
struct  lambda_group2
struct  lambda_group2.deduce_result_type
struct  lambda_group3
struct  lambda_group3.deduce_result_type
struct  lambda_operator
struct  lambda_operator.deduce_result_type
struct  lambda_operator_convert
struct  lambda_operator_convert.deduce_result_type
struct  lambda_operator_unary
struct  lambda_operator_unary.deduce_result_type
struct  leftshift
struct  less
struct  less_equal
struct  logical
class  mem_functor0
 mem_functor0 wraps methods with 0 argument(s). More...

class  mem_functor1
 mem_functor1 wraps methods with 1 argument(s). More...

class  mem_functor2
 mem_functor2 wraps methods with 2 argument(s). More...

class  mem_functor3
 mem_functor3 wraps methods with 3 argument(s). More...

class  mem_functor4
 mem_functor4 wraps methods with 4 argument(s). More...

class  mem_functor5
 mem_functor5 wraps methods with 5 argument(s). More...

class  mem_functor6
 mem_functor6 wraps methods with 6 argument(s). More...

class  mem_functor7
 mem_functor7 wraps methods with 7 argument(s). More...

struct  minus
struct  modulus
struct  multiplies
struct  negate
struct  not_
struct  not_equal_to
struct  or_
struct  other
struct  plus
class  pointer_functor0
 pointer_functor0 wraps existing non-member functions with 0 argument(s). More...

class  pointer_functor1
 pointer_functor1 wraps existing non-member functions with 1 argument(s). More...

class  pointer_functor2
 pointer_functor2 wraps existing non-member functions with 2 argument(s). More...

class  pointer_functor3
 pointer_functor3 wraps existing non-member functions with 3 argument(s). More...

class  pointer_functor4
 pointer_functor4 wraps existing non-member functions with 4 argument(s). More...

class  pointer_functor5
 pointer_functor5 wraps existing non-member functions with 5 argument(s). More...

class  pointer_functor6
 pointer_functor6 wraps existing non-member functions with 6 argument(s). More...

class  pointer_functor7
 pointer_functor7 wraps existing non-member functions with 7 argument(s). More...

struct  pre_decrement
struct  pre_increment
struct  reference_wrapper
struct  reinterpret_
struct  relational
struct  retype_functor
struct  retype_functor.deduce_result_type
struct  retype_return_functor
struct  retype_return_functor.deduce_result_type
struct  retype_return_functor<void, T_functor>
struct  retype_return_functor<void, T_functor>.deduce_result_type
struct  rightshift
class  signal
 Convenience wrapper for the numbered sigc::signal# templates. More...

class  signal0
 Signal declaration. More...

class  signal1
 Signal declaration. More...

class  signal2
 Signal declaration. More...

class  signal3
 Signal declaration. More...

class  signal4
 Signal declaration. More...

class  signal5
 Signal declaration. More...

class  signal6
 Signal declaration. More...

class  signal7
 Signal declaration. More...

class  signal.accumulated
 Convenience wrapper for the numbered sigc::signal# templates. More...

class  signal<T_return>
 Convenience wrapper for the numbered sigc::signal0 template. More...

class  signal<T_return>.accumulated
 Convenience wrapper for the numbered sigc::signal0 template. More...

class  signal<T_return, T_arg1>
 Convenience wrapper for the numbered sigc::signal1 template. More...

class  signal<T_return, T_arg1>.accumulated
 Convenience wrapper for the numbered sigc::signal1 template. More...

class  signal<T_return, T_arg1, T_arg2>
 Convenience wrapper for the numbered sigc::signal2 template. More...

class  signal<T_return, T_arg1, T_arg2>.accumulated
 Convenience wrapper for the numbered sigc::signal2 template. More...

class  signal<T_return, T_arg1, T_arg2, T_arg3>
 Convenience wrapper for the numbered sigc::signal3 template. More...

class  signal<T_return, T_arg1, T_arg2, T_arg3>.accumulated
 Convenience wrapper for the numbered sigc::signal3 template. More...

class  signal<T_return, T_arg1, T_arg2, T_arg3, T_arg4>
 Convenience wrapper for the numbered sigc::signal4 template. More...

class  signal<T_return, T_arg1, T_arg2, T_arg3, T_arg4>.accumulated
 Convenience wrapper for the numbered sigc::signal4 template. More...

class  signal<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
 Convenience wrapper for the numbered sigc::signal5 template. More...

class  signal<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>.accumulated
 Convenience wrapper for the numbered sigc::signal5 template. More...

class  signal<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
 Convenience wrapper for the numbered sigc::signal6 template. More...

class  signal<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>.accumulated
 Convenience wrapper for the numbered sigc::signal6 template. More...

struct  signal_base
 Base class for the sigc::signal# templates. More...

class  slot
 Convenience wrapper for the numbered sigc::slot# templates. More...

class  slot0
 Converts an arbitrary functor to a unified type which is opaque. More...

class  slot1
 Converts an arbitrary functor to a unified type which is opaque. More...

class  slot2
 Converts an arbitrary functor to a unified type which is opaque. More...

class  slot3
 Converts an arbitrary functor to a unified type which is opaque. More...

class  slot4
 Converts an arbitrary functor to a unified type which is opaque. More...

class  slot5
 Converts an arbitrary functor to a unified type which is opaque. More...

class  slot6
 Converts an arbitrary functor to a unified type which is opaque. More...

class  slot7
 Converts an arbitrary functor to a unified type which is opaque. More...

class  slot<T_return>
 Convenience wrapper for the numbered sigc::slot0 template. More...

class  slot<T_return, T_arg1>
 Convenience wrapper for the numbered sigc::slot1 template. More...

class  slot<T_return, T_arg1, T_arg2>
 Convenience wrapper for the numbered sigc::slot2 template. More...

class  slot<T_return, T_arg1, T_arg2, T_arg3>
 Convenience wrapper for the numbered sigc::slot3 template. More...

class  slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4>
 Convenience wrapper for the numbered sigc::slot4 template. More...

class  slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
 Convenience wrapper for the numbered sigc::slot5 template. More...

class  slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
 Convenience wrapper for the numbered sigc::slot6 template. More...

class  slot_base
 Base type for slots. More...

struct  slot_const_iterator
 STL-style const iterator for slot_list. More...

struct  slot_iterator
 STL-style iterator for slot_list. More...

struct  slot_list
 STL-style list interface for sigc::signal#. More...

struct  static_
struct  subscript
struct  trackable
 Base class for objects with auto-disconnection. More...

struct  type_trait
struct  type_trait<const T_type&>
struct  type_trait<const_reference_wrapper<T_type>>
struct  type_trait<reference_wrapper<T_type>>
struct  type_trait<T_type&>
struct  type_trait< T_type[N]>
struct  type_trait<void>
struct  unary_arithmetic
struct  unary_bitwise
struct  unary_logical
struct  unary_other
struct  unwrap_reference
struct  unwrap_reference<const_reference_wrapper<T_type>>
struct  unwrap_reference<reference_wrapper<T_type>>
class  volatile_mem_functor0
 volatile_mem_functor0 wraps volatile methods with 0 argument(s). More...

class  volatile_mem_functor1
 volatile_mem_functor1 wraps volatile methods with 1 argument(s). More...

class  volatile_mem_functor2
 volatile_mem_functor2 wraps volatile methods with 2 argument(s). More...

class  volatile_mem_functor3
 volatile_mem_functor3 wraps volatile methods with 3 argument(s). More...

class  volatile_mem_functor4
 volatile_mem_functor4 wraps volatile methods with 4 argument(s). More...

class  volatile_mem_functor5
 volatile_mem_functor5 wraps volatile methods with 5 argument(s). More...

class  volatile_mem_functor6
 volatile_mem_functor6 wraps volatile methods with 6 argument(s). More...

class  volatile_mem_functor7
 volatile_mem_functor7 wraps volatile methods with 7 argument(s). More...

struct  xor_

Functions

template <class T_action, class T_functor> void visit_each (const T_action& _A_action, const adaptor_functor<T_functor>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, int T_loc, class T_functor, class T_bound> void visit_each (const T_action& _A_action, const bind_functor<T_loc, T_functor, T_bound>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_functor, class T_type1> void visit_each (const T_action& _A_action, const bind_functor<-1, T_functor, T_type1 >& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_functor, class T_type1, class T_type2> void visit_each (const T_action& _A_action, const bind_functor<-1, T_functor, T_type1, T_type2 >& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_functor, class T_type1, class T_type2, class T_type3> void visit_each (const T_action& _A_action, const bind_functor<-1, T_functor, T_type1, T_type2, T_type3 >& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_functor, class T_type1, class T_type2, class T_type3, class T_type4> void visit_each (const T_action& _A_action, const bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4 >& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5> void visit_each (const T_action& _A_action, const bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5 >& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6> void visit_each (const T_action& _A_action, const bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6 >& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6, class T_type7> void visit_each (const T_action& _A_action, const bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >& _A_target)
 Performs a functor on each of the targets of a functor.

template<int I_location, class T_bound1, class T_functor> bind_functor< I_location,
T_functor, typename unwrap_reference<
T_bound1 >::type > 
bind (const T_functor& _A_func, T_bound1 _A_b1)
 Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.

template<class T_type1, class T_functor> bind_functor<-1, T_functor,
typename unwrap_reference<
T_type1 >::type > 
bind (const T_functor& _A_func, T_type1 _A_b1)
 Creates an adaptor of type sigc::bind_functor which fixes the last 1 argument(s) of the passed functor.

template<class T_type1, class T_type2, class T_functor> bind_functor<-1, T_functor,
typename unwrap_reference<
T_type1 >::type, typename
unwrap_reference< T_type2
>::type > 
bind (const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2)
 Creates an adaptor of type sigc::bind_functor which fixes the last 2 argument(s) of the passed functor.

template<class T_type1, class T_type2, class T_type3, class T_functor> bind_functor<-1, T_functor,
typename unwrap_reference<
T_type1 >::type, typename
unwrap_reference< T_type2
>::type, typename unwrap_reference<
T_type3 >::type > 
bind (const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3)
 Creates an adaptor of type sigc::bind_functor which fixes the last 3 argument(s) of the passed functor.

template<class T_type1, class T_type2, class T_type3, class T_type4, class T_functor> bind_functor<-1, T_functor,
typename unwrap_reference<
T_type1 >::type, typename
unwrap_reference< T_type2
>::type, typename unwrap_reference<
T_type3 >::type, typename
unwrap_reference< T_type4
>::type > 
bind (const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4)
 Creates an adaptor of type sigc::bind_functor which fixes the last 4 argument(s) of the passed functor.

template<class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_functor> bind_functor<-1, T_functor,
typename unwrap_reference<
T_type1 >::type, typename
unwrap_reference< T_type2
>::type, typename unwrap_reference<
T_type3 >::type, typename
unwrap_reference< T_type4
>::type, typename unwrap_reference<
T_type5 >::type > 
bind (const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5)
 Creates an adaptor of type sigc::bind_functor which fixes the last 5 argument(s) of the passed functor.

template<class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6, class T_functor> bind_functor<-1, T_functor,
typename unwrap_reference<
T_type1 >::type, typename
unwrap_reference< T_type2
>::type, typename unwrap_reference<
T_type3 >::type, typename
unwrap_reference< T_type4
>::type, typename unwrap_reference<
T_type5 >::type, typename
unwrap_reference< T_type6
>::type > 
bind (const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5, T_type6 _A_b6)
 Creates an adaptor of type sigc::bind_functor which fixes the last 6 argument(s) of the passed functor.

template<class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6, class T_type7, class T_functor> bind_functor<-1, T_functor,
typename unwrap_reference<
T_type1 >::type, typename
unwrap_reference< T_type2
>::type, typename unwrap_reference<
T_type3 >::type, typename
unwrap_reference< T_type4
>::type, typename unwrap_reference<
T_type5 >::type, typename
unwrap_reference< T_type6
>::type, typename unwrap_reference<
T_type7 >::type > 
bind (const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5, T_type6 _A_b6, T_type7 _A_b7)
 Creates an adaptor of type sigc::bind_functor which fixes the last 7 argument(s) of the passed functor.

template <class T_action, class T_return, class T_functor> void visit_each (const T_action& _A_action, const bind_return_functor<T_return, T_functor>& _A_target)
template <class T_return, class T_functor> bind_return_functor< typename
unwrap_reference< T_return
>::type, T_functor > 
bind_return (const T_functor& _A_functor, T_return _A_ret_value)
template <class T_action, class T_setter, class T_getter> void visit_each (const T_action& _A_action, const compose1_functor<T_setter, T_getter>& _A_target)
template <class T_action, class T_setter, class T_getter1, class T_getter2> void visit_each (const T_action& _A_action, const compose2_functor<T_setter, T_getter1, T_getter2>& _A_target)
template <class T_setter, class T_getter> compose1_functor< T_setter,
T_getter > 
compose (const T_setter& _A_setter, const T_getter& _A_getter)
template <class T_setter, class T_getter1, class T_getter2> compose2_functor< T_setter,
T_getter1, T_getter2 > 
compose (const T_setter& _A_setter, const T_getter1& _A_getter1, const T_getter2& _A_getter2)
template <class T_action, class T_functor, class T_catcher, class T_return> void visit_each (const T_action& _A_action, const exception_catch_functor<T_functor, T_catcher, T_return>& _A_target)
template <class T_functor, class T_catcher> exception_catch_functor< T_functor,
T_catcher > 
exception_catch (const T_functor& _A_func, const T_catcher& _A_catcher)
template <class T_action, int I_location, class T_functor> void visit_each (const T_action& _A_action, const hide_functor<I_location, T_functor>& _A_target)
 Performs a functor on each of the targets of a functor.

template<int I_location, class T_functor> hide_functor< I_location,
T_functor > 
hide (const T_functor& _A_func)
 Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor.

template <class T_action, class T_functor, bool I_islambda> void visit_each (const T_action& _A_action, const internal::lambda_core<T_functor, I_islambda>& _A_target)
template <class T_action, class T_type> void visit_each (const T_action& _A_action, const lambda<T_type>& _A_target)
template <class T_type> lambda<T_type> constant (const T_type& v)
template <class T_type> lambda<T_type&> var (T_type& v)
template <class T_type> lambda<const T_type&> var (const T_type& v)
template <class T_action, class T_functor, class T_type1> void visit_each (const T_action& _A_action, const lambda_group1<T_functor, T_type1>& _A_target)
template <class T_action, class T_functor, class T_type1, class T_type2> void visit_each (const T_action& _A_action, const lambda_group2<T_functor, T_type1, T_type2>& _A_target)
template <class T_action, class T_functor, class T_type1, class T_type2, class T_type3> void visit_each (const T_action& _A_action, const lambda_group3<T_functor, T_type1, T_type2, T_type3>& _A_target)
template <class T_functor, class T_type1> lambda< lambda_group1< T_functor,
typename unwrap_reference<
T_type1 >::type > > 
group (const T_functor& _A_func, T_type1 _A_1)
template <class T_functor, class T_type1, class T_type2> lambda< lambda_group2< T_functor,
typename unwrap_reference<
T_type1 >::type, typename
unwrap_reference< T_type2
>::type > > 
group (const T_functor& _A_func, T_type1 _A_1, T_type2 _A_2)
template <class T_functor, class T_type1, class T_type2, class T_type3> lambda< lambda_group3< T_functor,
typename unwrap_reference<
T_type1 >::type, typename
unwrap_reference< T_type2
>::type, typename unwrap_reference<
T_type3 >::type > > 
group (const T_functor& _A_func, T_type1 _A_1, T_type2 _A_2, T_type3 _A_3)
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, T_arg2 a2)
template <class T_arg1, class T_arg2> lambda< lambda_operator<arithmetic<
plus >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator+ (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, T_arg2 a2)
template <class T_arg1, class T_arg2> lambda< lambda_operator<arithmetic<
minus >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator- (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, T_arg2 a2)
template <class T_arg1, class T_arg2> lambda< lambda_operator<arithmetic<
multiplies >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator* (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, T_arg2 a2)
template <class T_arg1, class T_arg2> lambda< lambda_operator<arithmetic<
divides >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator/ (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, T_arg2 a2)
template <class T_arg1, class T_arg2> lambda< lambda_operator<arithmetic<
modulus >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator% (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, T_arg2 a2)
template <class T_arg1, class T_arg2> lambda< lambda_operator<bitwise<
leftshift >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator<< (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, T_arg2 a2)
template <class T_arg1, class T_arg2> lambda< lambda_operator<bitwise<
rightshift >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator>> (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, T_arg2 a2)
template <class T_arg1, class T_arg2> lambda< lambda_operator<bitwise<
and_ >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator& (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, T_arg2 a2)
template <class T_arg1, class T_arg2> lambda< lambda_operator<bitwise<
or_ >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator| (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, T_arg2 a2)
template <class T_arg1, class T_arg2> lambda< lambda_operator<bitwise<
xor_ >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator^ (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, T_arg2 a2)
template <class T_arg1, class T_arg2> lambda< lambda_operator<logical<
and_ >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator&& (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, T_arg2 a2)
template <class T_arg1, class T_arg2> lambda< lambda_operator<logical<
or_ >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator|| (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, T_arg2 a2)
template <class T_arg1, class T_arg2> lambda< lambda_operator<relational<
less >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator< (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, T_arg2 a2)
template <class T_arg1, class T_arg2> lambda< lambda_operator<relational<
greater >, typename unwrap_reference<
T_arg1 >::type, T_arg2 > > 
operator> (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, 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<= (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, 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>= (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, 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== (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, 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!= (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, 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+= (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, 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-= (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, 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*= (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, 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/= (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, 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%= (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, 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<<= (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, 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>>= (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, 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&= (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, 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|= (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, 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^= (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,
T_arg > > 
reinterpret_cast_ (const lambda<T_arg>& a)
template <class T_type, class T_arg> lambda< lambda_operator_convert<
cast_<static_>, T_type,
T_arg > > 
static_cast_ (const lambda<T_arg>& a)
template <class T_type, class T_arg> lambda< lambda_operator_convert<
cast_<dynamic_>, T_type,
T_arg > > 
dynamic_cast_ (const lambda<T_arg>& a)
template <class T_action, class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6, class T_type7> void visit_each (const T_action& _A_action, const retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>& _A_target)
template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> retype_functor< slot< T_return,
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5, T_arg6, T_arg7 >,
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5, T_arg6, T_arg7 > 
retype (const slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
template <class T_return> retype_functor< pointer_functor0<
T_return > > 
retype (const pointer_functor0<T_return>& _A_functor)
template <class T_arg1, class T_return> retype_functor< pointer_functor1<
T_arg1, T_return >, T_arg1 > 
retype (const pointer_functor1<T_arg1, T_return>& _A_functor)
template <class T_arg1, class T_arg2, class T_return> retype_functor< pointer_functor2<
T_arg1, T_arg2, T_return >,
T_arg1, T_arg2 > 
retype (const pointer_functor2<T_arg1, T_arg2, T_return>& _A_functor)
template <class T_arg1, class T_arg2, class T_arg3, class T_return> retype_functor< pointer_functor3<
T_arg1, T_arg2, T_arg3, T_return >,
T_arg1, T_arg2, T_arg3 > 
retype (const pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>& _A_functor)
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return> retype_functor< pointer_functor4<
T_arg1, T_arg2, T_arg3, T_arg4,
T_return >, T_arg1, T_arg2,
T_arg3, T_arg4 > 
retype (const pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>& _A_functor)
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return> retype_functor< pointer_functor5<
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5, T_return >, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5 > 
retype (const pointer_functor5<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return>& _A_functor)
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return> retype_functor< pointer_functor6<
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5, T_arg6, T_return >,
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5, T_arg6 > 
retype (const pointer_functor6<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return>& _A_functor)
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return> retype_functor< pointer_functor7<
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5, T_arg6, T_arg7, T_return >,
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5, T_arg6, T_arg7 > 
retype (const pointer_functor7<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return>& _A_functor)
template <class T_return, class T_obj> retype_functor< mem_functor0<
T_return, T_obj > > 
retype (const mem_functor0<T_return, T_obj>& _A_functor)
template <class T_return, class T_obj, class T_arg1> retype_functor< mem_functor1<
T_return, T_obj, T_arg1 >,
T_arg1 > 
retype (const mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2> retype_functor< mem_functor2<
T_return, T_obj, T_arg1,
T_arg2 >, T_arg1, T_arg2 > 
retype (const mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3> retype_functor< mem_functor3<
T_return, T_obj, T_arg1,
T_arg2, T_arg3 >, T_arg1,
T_arg2, T_arg3 > 
retype (const mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4> retype_functor< mem_functor4<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4 >,
T_arg1, T_arg2, T_arg3, T_arg4 > 
retype (const mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> retype_functor< mem_functor5<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5 >,
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5 > 
retype (const mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> retype_functor< mem_functor6<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6 >, T_arg1, T_arg2,
T_arg3, T_arg4, T_arg5, T_arg6 > 
retype (const mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> retype_functor< mem_functor7<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 >, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 > 
retype (const mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
template <class T_return, class T_obj> retype_functor< const_mem_functor0<
T_return, T_obj > > 
retype (const const_mem_functor0<T_return, T_obj>& _A_functor)
template <class T_return, class T_obj, class T_arg1> retype_functor< const_mem_functor1<
T_return, T_obj, T_arg1 >,
T_arg1 > 
retype (const const_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2> retype_functor< const_mem_functor2<
T_return, T_obj, T_arg1,
T_arg2 >, T_arg1, T_arg2 > 
retype (const const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3> retype_functor< const_mem_functor3<
T_return, T_obj, T_arg1,
T_arg2, T_arg3 >, T_arg1,
T_arg2, T_arg3 > 
retype (const const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4> retype_functor< const_mem_functor4<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4 >,
T_arg1, T_arg2, T_arg3, T_arg4 > 
retype (const const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> retype_functor< const_mem_functor5<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5 >,
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5 > 
retype (const const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> retype_functor< const_mem_functor6<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6 >, T_arg1, T_arg2,
T_arg3, T_arg4, T_arg5, T_arg6 > 
retype (const const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> retype_functor< const_mem_functor7<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 >, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 > 
retype (const const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
template <class T_return, class T_obj> retype_functor< volatile_mem_functor0<
T_return, T_obj > > 
retype (const volatile_mem_functor0<T_return, T_obj>& _A_functor)
template <class T_return, class T_obj, class T_arg1> retype_functor< volatile_mem_functor1<
T_return, T_obj, T_arg1 >,
T_arg1 > 
retype (const volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2> retype_functor< volatile_mem_functor2<
T_return, T_obj, T_arg1,
T_arg2 >, T_arg1, T_arg2 > 
retype (const volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3> retype_functor< volatile_mem_functor3<
T_return, T_obj, T_arg1,
T_arg2, T_arg3 >, T_arg1,
T_arg2, T_arg3 > 
retype (const volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4> retype_functor< volatile_mem_functor4<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4 >,
T_arg1, T_arg2, T_arg3, T_arg4 > 
retype (const volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> retype_functor< volatile_mem_functor5<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5 >,
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5 > 
retype (const volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> retype_functor< volatile_mem_functor6<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6 >, T_arg1, T_arg2,
T_arg3, T_arg4, T_arg5, T_arg6 > 
retype (const volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> retype_functor< volatile_mem_functor7<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 >, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 > 
retype (const volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
template <class T_return, class T_obj> retype_functor< const_volatile_mem_functor0<
T_return, T_obj > > 
retype (const const_volatile_mem_functor0<T_return, T_obj>& _A_functor)
template <class T_return, class T_obj, class T_arg1> retype_functor< const_volatile_mem_functor1<
T_return, T_obj, T_arg1 >,
T_arg1 > 
retype (const const_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2> retype_functor< const_volatile_mem_functor2<
T_return, T_obj, T_arg1,
T_arg2 >, T_arg1, T_arg2 > 
retype (const const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3> retype_functor< const_volatile_mem_functor3<
T_return, T_obj, T_arg1,
T_arg2, T_arg3 >, T_arg1,
T_arg2, T_arg3 > 
retype (const const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4> retype_functor< const_volatile_mem_functor4<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4 >,
T_arg1, T_arg2, T_arg3, T_arg4 > 
retype (const const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> retype_functor< const_volatile_mem_functor5<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5 >,
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5 > 
retype (const const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> retype_functor< const_volatile_mem_functor6<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6 >, T_arg1, T_arg2,
T_arg3, T_arg4, T_arg5, T_arg6 > 
retype (const const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> retype_functor< const_volatile_mem_functor7<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 >, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 > 
retype (const const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
template <class T_return, class T_obj> retype_functor< bound_mem_functor0<
T_return, T_obj > > 
retype (const bound_mem_functor0<T_return, T_obj>& _A_functor)
template <class T_return, class T_obj, class T_arg1> retype_functor< bound_mem_functor1<
T_return, T_obj, T_arg1 >,
T_arg1 > 
retype (const bound_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2> retype_functor< bound_mem_functor2<
T_return, T_obj, T_arg1,
T_arg2 >, T_arg1, T_arg2 > 
retype (const bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3> retype_functor< bound_mem_functor3<
T_return, T_obj, T_arg1,
T_arg2, T_arg3 >, T_arg1,
T_arg2, T_arg3 > 
retype (const bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4> retype_functor< bound_mem_functor4<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4 >,
T_arg1, T_arg2, T_arg3, T_arg4 > 
retype (const bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> retype_functor< bound_mem_functor5<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5 >,
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5 > 
retype (const bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> retype_functor< bound_mem_functor6<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6 >, T_arg1, T_arg2,
T_arg3, T_arg4, T_arg5, T_arg6 > 
retype (const bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> retype_functor< bound_mem_functor7<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 >, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 > 
retype (const bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
template <class T_return, class T_obj> retype_functor< bound_const_mem_functor0<
T_return, T_obj > > 
retype (const bound_const_mem_functor0<T_return, T_obj>& _A_functor)
template <class T_return, class T_obj, class T_arg1> retype_functor< bound_const_mem_functor1<
T_return, T_obj, T_arg1 >,
T_arg1 > 
retype (const bound_const_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2> retype_functor< bound_const_mem_functor2<
T_return, T_obj, T_arg1,
T_arg2 >, T_arg1, T_arg2 > 
retype (const bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3> retype_functor< bound_const_mem_functor3<
T_return, T_obj, T_arg1,
T_arg2, T_arg3 >, T_arg1,
T_arg2, T_arg3 > 
retype (const bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4> retype_functor< bound_const_mem_functor4<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4 >,
T_arg1, T_arg2, T_arg3, T_arg4 > 
retype (const bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> retype_functor< bound_const_mem_functor5<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5 >,
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5 > 
retype (const bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> retype_functor< bound_const_mem_functor6<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6 >, T_arg1, T_arg2,
T_arg3, T_arg4, T_arg5, T_arg6 > 
retype (const bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> retype_functor< bound_const_mem_functor7<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 >, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 > 
retype (const bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
template <class T_return, class T_obj> retype_functor< bound_volatile_mem_functor0<
T_return, T_obj > > 
retype (const bound_volatile_mem_functor0<T_return, T_obj>& _A_functor)
template <class T_return, class T_obj, class T_arg1> retype_functor< bound_volatile_mem_functor1<
T_return, T_obj, T_arg1 >,
T_arg1 > 
retype (const bound_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2> retype_functor< bound_volatile_mem_functor2<
T_return, T_obj, T_arg1,
T_arg2 >, T_arg1, T_arg2 > 
retype (const bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3> retype_functor< bound_volatile_mem_functor3<
T_return, T_obj, T_arg1,
T_arg2, T_arg3 >, T_arg1,
T_arg2, T_arg3 > 
retype (const bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4> retype_functor< bound_volatile_mem_functor4<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4 >,
T_arg1, T_arg2, T_arg3, T_arg4 > 
retype (const bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> retype_functor< bound_volatile_mem_functor5<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5 >,
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5 > 
retype (const bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> retype_functor< bound_volatile_mem_functor6<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6 >, T_arg1, T_arg2,
T_arg3, T_arg4, T_arg5, T_arg6 > 
retype (const bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> retype_functor< bound_volatile_mem_functor7<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 >, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 > 
retype (const bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
template <class T_return, class T_obj> retype_functor< bound_const_volatile_mem_functor0<
T_return, T_obj > > 
retype (const bound_const_volatile_mem_functor0<T_return, T_obj>& _A_functor)
template <class T_return, class T_obj, class T_arg1> retype_functor< bound_const_volatile_mem_functor1<
T_return, T_obj, T_arg1 >,
T_arg1 > 
retype (const bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2> retype_functor< bound_const_volatile_mem_functor2<
T_return, T_obj, T_arg1,
T_arg2 >, T_arg1, T_arg2 > 
retype (const bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3> retype_functor< bound_const_volatile_mem_functor3<
T_return, T_obj, T_arg1,
T_arg2, T_arg3 >, T_arg1,
T_arg2, T_arg3 > 
retype (const bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4> retype_functor< bound_const_volatile_mem_functor4<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4 >,
T_arg1, T_arg2, T_arg3, T_arg4 > 
retype (const bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> retype_functor< bound_const_volatile_mem_functor5<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5 >,
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5 > 
retype (const bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> retype_functor< bound_const_volatile_mem_functor6<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6 >, T_arg1, T_arg2,
T_arg3, T_arg4, T_arg5, T_arg6 > 
retype (const bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> retype_functor< bound_const_volatile_mem_functor7<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 >, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 > 
retype (const bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
template <class T_action, class T_return, class T_functor> void visit_each (const T_action& _A_action, const retype_return_functor<T_return, T_functor>& _A_target)
template <class T_return, class T_functor> retype_return_functor< T_return,
T_functor > 
retype_return (const T_functor& _A_functor)
template <class T_functor> retype_return_functor< void,
T_functor > 
hide_return (const T_functor& _A_functor)
template <class T_action, class T_return, class T_obj> void visit_each (const T_action& _A_action, const bound_mem_functor0<T_return, T_obj>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1> void visit_each (const T_action& _A_action, const bound_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2> void visit_each (const T_action& _A_action, const bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3> void visit_each (const T_action& _A_action, const bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4> void visit_each (const T_action& _A_action, const bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> void visit_each (const T_action& _A_action, const bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> void visit_each (const T_action& _A_action, const bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> void visit_each (const T_action& _A_action, const bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj> void visit_each (const T_action& _A_action, const bound_const_mem_functor0<T_return, T_obj>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1> void visit_each (const T_action& _A_action, const bound_const_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2> void visit_each (const T_action& _A_action, const bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3> void visit_each (const T_action& _A_action, const bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4> void visit_each (const T_action& _A_action, const bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> void visit_each (const T_action& _A_action, const bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> void visit_each (const T_action& _A_action, const bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> void visit_each (const T_action& _A_action, const bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj> void visit_each (const T_action& _A_action, const bound_volatile_mem_functor0<T_return, T_obj>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1> void visit_each (const T_action& _A_action, const bound_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2> void visit_each (const T_action& _A_action, const bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3> void visit_each (const T_action& _A_action, const bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4> void visit_each (const T_action& _A_action, const bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> void visit_each (const T_action& _A_action, const bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> void visit_each (const T_action& _A_action, const bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> void visit_each (const T_action& _A_action, const bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj> void visit_each (const T_action& _A_action, const bound_const_volatile_mem_functor0<T_return, T_obj>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1> void visit_each (const T_action& _A_action, const bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2> void visit_each (const T_action& _A_action, const bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3> void visit_each (const T_action& _A_action, const bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4> void visit_each (const T_action& _A_action, const bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> void visit_each (const T_action& _A_action, const bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> void visit_each (const T_action& _A_action, const bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_action, class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> void visit_each (const T_action& _A_action, const bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_target)
 Performs a functor on each of the targets of a functor.

template <class T_return, class T_obj> mem_functor0<T_return, T_obj> mem_fun0 (T_return(T_obj::* _A_func)())
 Creates a functor of type sigc::mem_functor0 which wraps a method.

template <class T_arg1, class T_return, class T_obj> mem_functor1< T_return, T_obj,
T_arg1 > 
mem_fun1 (T_return(T_obj::* _A_func)(T_arg1))
 Creates a functor of type sigc::mem_functor1 which wraps a method.

template <class T_arg1, class T_arg2, class T_return, class T_obj> mem_functor2< T_return, T_obj,
T_arg1, T_arg2 > 
mem_fun2 (T_return(T_obj::* _A_func)(T_arg1, T_arg2))
 Creates a functor of type sigc::mem_functor2 which wraps a method.

template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj> mem_functor3< T_return, T_obj,
T_arg1, T_arg2, T_arg3 > 
mem_fun3 (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3))
 Creates a functor of type sigc::mem_functor3 which wraps a method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj> mem_functor4< T_return, T_obj,
T_arg1, T_arg2, T_arg3, T_arg4 > 
mem_fun4 (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))
 Creates a functor of type sigc::mem_functor4 which wraps a method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj> mem_functor5< T_return, T_obj,
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5 > 
mem_fun5 (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))
 Creates a functor of type sigc::mem_functor5 which wraps a method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj> mem_functor6< T_return, T_obj,
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5, T_arg6 > 
mem_fun6 (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))
 Creates a functor of type sigc::mem_functor6 which wraps a method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj> mem_functor7< T_return, T_obj,
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5, T_arg6, T_arg7 > 
mem_fun7 (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))
 Creates a functor of type sigc::mem_functor7 which wraps a method.

template <class T_return, class T_obj> const_mem_functor0< T_return,
T_obj > 
mem_fun0 (T_return(T_obj::* _A_func)() const)
 Creates a functor of type sigc::const_mem_functor0 which wraps a const method.

template <class T_arg1, class T_return, class T_obj> const_mem_functor1< T_return,
T_obj, T_arg1 > 
mem_fun1 (T_return(T_obj::* _A_func)(T_arg1) const)
 Creates a functor of type sigc::const_mem_functor1 which wraps a const method.

template <class T_arg1, class T_arg2, class T_return, class T_obj> const_mem_functor2< T_return,
T_obj, T_arg1, T_arg2 > 
mem_fun2 (T_return(T_obj::* _A_func)(T_arg1, T_arg2) const)
 Creates a functor of type sigc::const_mem_functor2 which wraps a const method.

template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj> const_mem_functor3< T_return,
T_obj, T_arg1, T_arg2, T_arg3 > 
mem_fun3 (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3) const)
 Creates a functor of type sigc::const_mem_functor3 which wraps a const method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj> const_mem_functor4< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4 > 
mem_fun4 (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
 Creates a functor of type sigc::const_mem_functor4 which wraps a const method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj> const_mem_functor5< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4, T_arg5 > 
mem_fun5 (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
 Creates a functor of type sigc::const_mem_functor5 which wraps a const method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj> const_mem_functor6< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4, T_arg5, T_arg6 > 
mem_fun6 (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
 Creates a functor of type sigc::const_mem_functor6 which wraps a const method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj> const_mem_functor7< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4, T_arg5, T_arg6, T_arg7 > 
mem_fun7 (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
 Creates a functor of type sigc::const_mem_functor7 which wraps a const method.

template <class T_return, class T_obj> volatile_mem_functor0< T_return,
T_obj > 
mem_fun0 (T_return(T_obj::* _A_func)() volatile)
 Creates a functor of type sigc::const_volatile_mem_functor0 which wraps a const volatile method.

template <class T_arg1, class T_return, class T_obj> volatile_mem_functor1< T_return,
T_obj, T_arg1 > 
mem_fun1 (T_return(T_obj::* _A_func)(T_arg1) volatile)
 Creates a functor of type sigc::const_volatile_mem_functor1 which wraps a const volatile method.

template <class T_arg1, class T_arg2, class T_return, class T_obj> volatile_mem_functor2< T_return,
T_obj, T_arg1, T_arg2 > 
mem_fun2 (T_return(T_obj::* _A_func)(T_arg1, T_arg2) volatile)
 Creates a functor of type sigc::const_volatile_mem_functor2 which wraps a const volatile method.

template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj> volatile_mem_functor3< T_return,
T_obj, T_arg1, T_arg2, T_arg3 > 
mem_fun3 (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3) volatile)
 Creates a functor of type sigc::const_volatile_mem_functor3 which wraps a const volatile method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj> volatile_mem_functor4< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4 > 
mem_fun4 (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
 Creates a functor of type sigc::const_volatile_mem_functor4 which wraps a const volatile method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj> volatile_mem_functor5< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4, T_arg5 > 
mem_fun5 (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
 Creates a functor of type sigc::const_volatile_mem_functor5 which wraps a const volatile method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj> volatile_mem_functor6< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4, T_arg5, T_arg6 > 
mem_fun6 (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
 Creates a functor of type sigc::const_volatile_mem_functor6 which wraps a const volatile method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj> volatile_mem_functor7< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4, T_arg5, T_arg6, T_arg7 > 
mem_fun7 (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
 Creates a functor of type sigc::const_volatile_mem_functor7 which wraps a const volatile method.

template <class T_return, class T_obj, class T_obj2> bound_mem_functor0< T_return,
T_obj > 
mem_fun0 (T_obj& _A_obj, T_return(T_obj2::* _A_func)())
 Creates a functor of type sigc::bound_mem_functor0 which encapsulates a method and an object instance.

template <class T_arg1, class T_return, class T_obj, class T_obj2> bound_mem_functor1< T_return,
T_obj, T_arg1 > 
mem_fun1 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1))
 Creates a functor of type sigc::bound_mem_functor1 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2> bound_mem_functor2< T_return,
T_obj, T_arg1, T_arg2 > 
mem_fun2 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2))
 Creates a functor of type sigc::bound_mem_functor2 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2> bound_mem_functor3< T_return,
T_obj, T_arg1, T_arg2, T_arg3 > 
mem_fun3 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3))
 Creates a functor of type sigc::bound_mem_functor3 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2> bound_mem_functor4< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4 > 
mem_fun4 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))
 Creates a functor of type sigc::bound_mem_functor4 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2> bound_mem_functor5< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4, T_arg5 > 
mem_fun5 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))
 Creates a functor of type sigc::bound_mem_functor5 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2> bound_mem_functor6< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4, T_arg5, T_arg6 > 
mem_fun6 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))
 Creates a functor of type sigc::bound_mem_functor6 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2> bound_mem_functor7< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4, T_arg5, T_arg6, T_arg7 > 
mem_fun7 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))
 Creates a functor of type sigc::bound_mem_functor7 which encapsulates a method and an object instance.

template <class T_return, class T_obj, class T_obj2> bound_const_mem_functor0<
T_return, T_obj > 
mem_fun0 (T_obj* _A_obj, T_return(T_obj2::* _A_func)() const)
 Creates a functor of type sigc::bound_const_mem_functor0 which encapsulates a method and an object instance.

template <class T_return, class T_obj, class T_obj2> bound_const_mem_functor0<
T_return, T_obj > 
mem_fun0 (T_obj& _A_obj, T_return(T_obj2::* _A_func)() const)
 Creates a functor of type sigc::bound_const_mem_functor0 which encapsulates a method and an object instance.

template <class T_arg1, class T_return, class T_obj, class T_obj2> bound_const_mem_functor1<
T_return, T_obj, T_arg1 > 
mem_fun1 (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const)
 Creates a functor of type sigc::bound_const_mem_functor1 which encapsulates a method and an object instance.

template <class T_arg1, class T_return, class T_obj, class T_obj2> bound_const_mem_functor1<
T_return, T_obj, T_arg1 > 
mem_fun1 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const)
 Creates a functor of type sigc::bound_const_mem_functor1 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2> bound_const_mem_functor2<
T_return, T_obj, T_arg1,
T_arg2 > 
mem_fun2 (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const)
 Creates a functor of type sigc::bound_const_mem_functor2 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2> bound_const_mem_functor2<
T_return, T_obj, T_arg1,
T_arg2 > 
mem_fun2 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const)
 Creates a functor of type sigc::bound_const_mem_functor2 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2> bound_const_mem_functor3<
T_return, T_obj, T_arg1,
T_arg2, T_arg3 > 
mem_fun3 (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const)
 Creates a functor of type sigc::bound_const_mem_functor3 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2> bound_const_mem_functor3<
T_return, T_obj, T_arg1,
T_arg2, T_arg3 > 
mem_fun3 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const)
 Creates a functor of type sigc::bound_const_mem_functor3 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2> bound_const_mem_functor4<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4 > 
mem_fun4 (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
 Creates a functor of type sigc::bound_const_mem_functor4 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2> bound_const_mem_functor4<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4 > 
mem_fun4 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
 Creates a functor of type sigc::bound_const_mem_functor4 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2> bound_const_mem_functor5<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5 > 
mem_fun5 (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
 Creates a functor of type sigc::bound_const_mem_functor5 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2> bound_const_mem_functor5<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5 > 
mem_fun5 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
 Creates a functor of type sigc::bound_const_mem_functor5 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2> bound_const_mem_functor6<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6 > 
mem_fun6 (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
 Creates a functor of type sigc::bound_const_mem_functor6 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2> bound_const_mem_functor6<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6 > 
mem_fun6 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
 Creates a functor of type sigc::bound_const_mem_functor6 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2> bound_const_mem_functor7<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 > 
mem_fun7 (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
 Creates a functor of type sigc::bound_const_mem_functor7 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2> bound_const_mem_functor7<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 > 
mem_fun7 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
 Creates a functor of type sigc::bound_const_mem_functor7 which encapsulates a method and an object instance.

template <class T_return, class T_obj, class T_obj2> bound_volatile_mem_functor0<
T_return, T_obj > 
mem_fun0 (T_obj& _A_obj, T_return(T_obj2::* _A_func)() volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor0 which encapsulates a method and an object instance.

template <class T_arg1, class T_return, class T_obj, class T_obj2> bound_volatile_mem_functor1<
T_return, T_obj, T_arg1 > 
mem_fun1 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1) volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor1 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2> bound_volatile_mem_functor2<
T_return, T_obj, T_arg1,
T_arg2 > 
mem_fun2 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor2 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2> bound_volatile_mem_functor3<
T_return, T_obj, T_arg1,
T_arg2, T_arg3 > 
mem_fun3 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor3 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2> bound_volatile_mem_functor4<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4 > 
mem_fun4 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor4 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2> bound_volatile_mem_functor5<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5 > 
mem_fun5 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor5 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2> bound_volatile_mem_functor6<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6 > 
mem_fun6 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor6 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2> bound_volatile_mem_functor7<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 > 
mem_fun7 (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor7 which encapsulates a method and an object instance.

template <class T_return, class T_obj, class T_obj2> bound_const_volatile_mem_functor0<
T_return, T_obj > 
mem_fun0 (T_obj* _A_obj, T_return(T_obj2::* _A_func)() const volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor0 which encapsulates a method and an object instance.

template <class T_arg1, class T_return, class T_obj, class T_obj2> bound_const_volatile_mem_functor1<
T_return, T_obj, T_arg1 > 
mem_fun1 (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor1 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2> bound_const_volatile_mem_functor2<
T_return, T_obj, T_arg1,
T_arg2 > 
mem_fun2 (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor2 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2> bound_const_volatile_mem_functor3<
T_return, T_obj, T_arg1,
T_arg2, T_arg3 > 
mem_fun3 (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor3 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2> bound_const_volatile_mem_functor4<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4 > 
mem_fun4 (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor4 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2> bound_const_volatile_mem_functor5<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5 > 
mem_fun5 (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor5 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2> bound_const_volatile_mem_functor6<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6 > 
mem_fun6 (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor6 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2> bound_const_volatile_mem_functor7<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 > 
mem_fun7 (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor7 which encapsulates a method and an object instance.

template <class T_return, class T_obj> mem_functor0<T_return, T_obj> mem_fun (T_return(T_obj::* _A_func)())
 Creates a functor of type sigc::mem_functor0 which wraps a method.

template <class T_arg1, class T_return, class T_obj> mem_functor1< T_return, T_obj,
T_arg1 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1))
 Creates a functor of type sigc::mem_functor1 which wraps a method.

template <class T_arg1, class T_arg2, class T_return, class T_obj> mem_functor2< T_return, T_obj,
T_arg1, T_arg2 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2))
 Creates a functor of type sigc::mem_functor2 which wraps a method.

template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj> mem_functor3< T_return, T_obj,
T_arg1, T_arg2, T_arg3 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3))
 Creates a functor of type sigc::mem_functor3 which wraps a method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj> mem_functor4< T_return, T_obj,
T_arg1, T_arg2, T_arg3, T_arg4 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))
 Creates a functor of type sigc::mem_functor4 which wraps a method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj> mem_functor5< T_return, T_obj,
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))
 Creates a functor of type sigc::mem_functor5 which wraps a method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj> mem_functor6< T_return, T_obj,
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5, T_arg6 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))
 Creates a functor of type sigc::mem_functor6 which wraps a method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj> mem_functor7< T_return, T_obj,
T_arg1, T_arg2, T_arg3, T_arg4,
T_arg5, T_arg6, T_arg7 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))
 Creates a functor of type sigc::mem_functor7 which wraps a method.

template <class T_return, class T_obj> const_mem_functor0< T_return,
T_obj > 
mem_fun (T_return(T_obj::* _A_func)() const)
 Creates a functor of type sigc::const_mem_functor0 which wraps a const method.

template <class T_arg1, class T_return, class T_obj> const_mem_functor1< T_return,
T_obj, T_arg1 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1) const)
 Creates a functor of type sigc::const_mem_functor1 which wraps a const method.

template <class T_arg1, class T_arg2, class T_return, class T_obj> const_mem_functor2< T_return,
T_obj, T_arg1, T_arg2 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2) const)
 Creates a functor of type sigc::const_mem_functor2 which wraps a const method.

template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj> const_mem_functor3< T_return,
T_obj, T_arg1, T_arg2, T_arg3 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3) const)
 Creates a functor of type sigc::const_mem_functor3 which wraps a const method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj> const_mem_functor4< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
 Creates a functor of type sigc::const_mem_functor4 which wraps a const method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj> const_mem_functor5< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4, T_arg5 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
 Creates a functor of type sigc::const_mem_functor5 which wraps a const method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj> const_mem_functor6< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4, T_arg5, T_arg6 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
 Creates a functor of type sigc::const_mem_functor6 which wraps a const method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj> const_mem_functor7< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4, T_arg5, T_arg6, T_arg7 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
 Creates a functor of type sigc::const_mem_functor7 which wraps a const method.

template <class T_return, class T_obj> volatile_mem_functor0< T_return,
T_obj > 
mem_fun (T_return(T_obj::* _A_func)() volatile)
 Creates a functor of type sigc::const_volatile_mem_functor0 which wraps a const volatile method.

template <class T_arg1, class T_return, class T_obj> volatile_mem_functor1< T_return,
T_obj, T_arg1 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1) volatile)
 Creates a functor of type sigc::const_volatile_mem_functor1 which wraps a const volatile method.

template <class T_arg1, class T_arg2, class T_return, class T_obj> volatile_mem_functor2< T_return,
T_obj, T_arg1, T_arg2 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2) volatile)
 Creates a functor of type sigc::const_volatile_mem_functor2 which wraps a const volatile method.

template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj> volatile_mem_functor3< T_return,
T_obj, T_arg1, T_arg2, T_arg3 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3) volatile)
 Creates a functor of type sigc::const_volatile_mem_functor3 which wraps a const volatile method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj> volatile_mem_functor4< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
 Creates a functor of type sigc::const_volatile_mem_functor4 which wraps a const volatile method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj> volatile_mem_functor5< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4, T_arg5 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
 Creates a functor of type sigc::const_volatile_mem_functor5 which wraps a const volatile method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj> volatile_mem_functor6< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4, T_arg5, T_arg6 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
 Creates a functor of type sigc::const_volatile_mem_functor6 which wraps a const volatile method.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj> volatile_mem_functor7< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4, T_arg5, T_arg6, T_arg7 > 
mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
 Creates a functor of type sigc::const_volatile_mem_functor7 which wraps a const volatile method.

template <class T_return, class T_obj, class T_obj2> bound_mem_functor0< T_return,
T_obj > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)())
 Creates a functor of type sigc::bound_mem_functor0 which encapsulates a method and an object instance.

template <class T_arg1, class T_return, class T_obj, class T_obj2> bound_mem_functor1< T_return,
T_obj, T_arg1 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1))
 Creates a functor of type sigc::bound_mem_functor1 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2> bound_mem_functor2< T_return,
T_obj, T_arg1, T_arg2 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2))
 Creates a functor of type sigc::bound_mem_functor2 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2> bound_mem_functor3< T_return,
T_obj, T_arg1, T_arg2, T_arg3 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3))
 Creates a functor of type sigc::bound_mem_functor3 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2> bound_mem_functor4< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))
 Creates a functor of type sigc::bound_mem_functor4 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2> bound_mem_functor5< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4, T_arg5 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))
 Creates a functor of type sigc::bound_mem_functor5 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2> bound_mem_functor6< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4, T_arg5, T_arg6 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))
 Creates a functor of type sigc::bound_mem_functor6 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2> bound_mem_functor7< T_return,
T_obj, T_arg1, T_arg2, T_arg3,
T_arg4, T_arg5, T_arg6, T_arg7 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))
 Creates a functor of type sigc::bound_mem_functor7 which encapsulates a method and an object instance.

template <class T_return, class T_obj, class T_obj2> bound_const_mem_functor0<
T_return, T_obj > 
mem_fun (T_obj* _A_obj, T_return(T_obj2::* _A_func)() const)
 Creates a functor of type sigc::bound_const_mem_functor0 which encapsulates a method and an object instance.

template <class T_return, class T_obj, class T_obj2> bound_const_mem_functor0<
T_return, T_obj > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)() const)
 Creates a functor of type sigc::bound_const_mem_functor0 which encapsulates a method and an object instance.

template <class T_arg1, class T_return, class T_obj, class T_obj2> bound_const_mem_functor1<
T_return, T_obj, T_arg1 > 
mem_fun (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const)
 Creates a functor of type sigc::bound_const_mem_functor1 which encapsulates a method and an object instance.

template <class T_arg1, class T_return, class T_obj, class T_obj2> bound_const_mem_functor1<
T_return, T_obj, T_arg1 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const)
 Creates a functor of type sigc::bound_const_mem_functor1 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2> bound_const_mem_functor2<
T_return, T_obj, T_arg1,
T_arg2 > 
mem_fun (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const)
 Creates a functor of type sigc::bound_const_mem_functor2 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2> bound_const_mem_functor2<
T_return, T_obj, T_arg1,
T_arg2 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const)
 Creates a functor of type sigc::bound_const_mem_functor2 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2> bound_const_mem_functor3<
T_return, T_obj, T_arg1,
T_arg2, T_arg3 > 
mem_fun (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const)
 Creates a functor of type sigc::bound_const_mem_functor3 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2> bound_const_mem_functor3<
T_return, T_obj, T_arg1,
T_arg2, T_arg3 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const)
 Creates a functor of type sigc::bound_const_mem_functor3 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2> bound_const_mem_functor4<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4 > 
mem_fun (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
 Creates a functor of type sigc::bound_const_mem_functor4 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2> bound_const_mem_functor4<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
 Creates a functor of type sigc::bound_const_mem_functor4 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2> bound_const_mem_functor5<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5 > 
mem_fun (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
 Creates a functor of type sigc::bound_const_mem_functor5 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2> bound_const_mem_functor5<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
 Creates a functor of type sigc::bound_const_mem_functor5 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2> bound_const_mem_functor6<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6 > 
mem_fun (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
 Creates a functor of type sigc::bound_const_mem_functor6 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2> bound_const_mem_functor6<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
 Creates a functor of type sigc::bound_const_mem_functor6 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2> bound_const_mem_functor7<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 > 
mem_fun (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
 Creates a functor of type sigc::bound_const_mem_functor7 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2> bound_const_mem_functor7<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
 Creates a functor of type sigc::bound_const_mem_functor7 which encapsulates a method and an object instance.

template <class T_return, class T_obj, class T_obj2> bound_volatile_mem_functor0<
T_return, T_obj > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)() volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor0 which encapsulates a method and an object instance.

template <class T_arg1, class T_return, class T_obj, class T_obj2> bound_volatile_mem_functor1<
T_return, T_obj, T_arg1 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1) volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor1 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2> bound_volatile_mem_functor2<
T_return, T_obj, T_arg1,
T_arg2 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor2 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2> bound_volatile_mem_functor3<
T_return, T_obj, T_arg1,
T_arg2, T_arg3 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor3 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2> bound_volatile_mem_functor4<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor4 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2> bound_volatile_mem_functor5<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor5 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2> bound_volatile_mem_functor6<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor6 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2> bound_volatile_mem_functor7<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor7 which encapsulates a method and an object instance.

template <class T_return, class T_obj, class T_obj2> bound_const_volatile_mem_functor0<
T_return, T_obj > 
mem_fun (T_obj* _A_obj, T_return(T_obj2::* _A_func)() const volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor0 which encapsulates a method and an object instance.

template <class T_arg1, class T_return, class T_obj, class T_obj2> bound_const_volatile_mem_functor1<
T_return, T_obj, T_arg1 > 
mem_fun (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor1 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2> bound_const_volatile_mem_functor2<
T_return, T_obj, T_arg1,
T_arg2 > 
mem_fun (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor2 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2> bound_const_volatile_mem_functor3<
T_return, T_obj, T_arg1,
T_arg2, T_arg3 > 
mem_fun (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor3 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2> bound_const_volatile_mem_functor4<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4 > 
mem_fun (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor4 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2> bound_const_volatile_mem_functor5<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5 > 
mem_fun (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor5 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2> bound_const_volatile_mem_functor6<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6 > 
mem_fun (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor6 which encapsulates a method and an object instance.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2> bound_const_volatile_mem_functor7<
T_return, T_obj, T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7 > 
mem_fun (T_obj* _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
 Creates a functor of type sigc::bound_const_volatile_mem_functor7 which encapsulates a method and an object instance.

template <class T_return> pointer_functor0<T_return> ptr_fun0 (T_return(* _A_func)())
 Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.

template <class T_arg1, class T_return> pointer_functor1< T_arg1,
T_return > 
ptr_fun1 (T_return(* _A_func)(T_arg1))
 Creates a functor of type sigc::pointer_functor1 which wraps an existing non-member function.

template <class T_arg1, class T_arg2, class T_return> pointer_functor2< T_arg1,
T_arg2, T_return > 
ptr_fun2 (T_return(* _A_func)(T_arg1, T_arg2))
 Creates a functor of type sigc::pointer_functor2 which wraps an existing non-member function.

template <class T_arg1, class T_arg2, class T_arg3, class T_return> pointer_functor3< T_arg1,
T_arg2, T_arg3, T_return > 
ptr_fun3 (T_return(* _A_func)(T_arg1, T_arg2, T_arg3))
 Creates a functor of type sigc::pointer_functor3 which wraps an existing non-member function.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return> pointer_functor4< T_arg1,
T_arg2, T_arg3, T_arg4, T_return > 
ptr_fun4 (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))
 Creates a functor of type sigc::pointer_functor4 which wraps an existing non-member function.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return> pointer_functor5< T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_return > 
ptr_fun5 (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))
 Creates a functor of type sigc::pointer_functor5 which wraps an existing non-member function.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return> pointer_functor6< T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_return > 
ptr_fun6 (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))
 Creates a functor of type sigc::pointer_functor6 which wraps an existing non-member function.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return> pointer_functor7< T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7, T_return > 
ptr_fun7 (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))
 Creates a functor of type sigc::pointer_functor7 which wraps an existing non-member function.

template <class T_return> pointer_functor0<T_return> ptr_fun (T_return(* _A_func)())
 Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.

template <class T_arg1, class T_return> pointer_functor1< T_arg1,
T_return > 
ptr_fun (T_return(* _A_func)(T_arg1))
 Creates a functor of type sigc::pointer_functor1 which wraps an existing non-member function.

template <class T_arg1, class T_arg2, class T_return> pointer_functor2< T_arg1,
T_arg2, T_return > 
ptr_fun (T_return(* _A_func)(T_arg1, T_arg2))
 Creates a functor of type sigc::pointer_functor2 which wraps an existing non-member function.

template <class T_arg1, class T_arg2, class T_arg3, class T_return> pointer_functor3< T_arg1,
T_arg2, T_arg3, T_return > 
ptr_fun (T_return(* _A_func)(T_arg1, T_arg2, T_arg3))
 Creates a functor of type sigc::pointer_functor3 which wraps an existing non-member function.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return> pointer_functor4< T_arg1,
T_arg2, T_arg3, T_arg4, T_return > 
ptr_fun (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))
 Creates a functor of type sigc::pointer_functor4 which wraps an existing non-member function.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return> pointer_functor5< T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_return > 
ptr_fun (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))
 Creates a functor of type sigc::pointer_functor5 which wraps an existing non-member function.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return> pointer_functor6< T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_return > 
ptr_fun (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))
 Creates a functor of type sigc::pointer_functor6 which wraps an existing non-member function.

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return> pointer_functor7< T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7, T_return > 
ptr_fun (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))
 Creates a functor of type sigc::pointer_functor7 which wraps an existing non-member function.

template <class T_type> reference_wrapper<T_type> ref (T_type& v)
template <class T_type> const_reference_wrapper<T_type> ref (const T_type& v)
template <class T_type> T_type& unwrap (T_type& v)
template <class T_type> const T_type& unwrap (const T_type& v)
template <class T_type> T_type& unwrap (const reference_wrapper<T_type>& v)
template <class T_type> const T_type& unwrap (const const_reference_wrapper<T_type>& v)
template <class T_action, class T_functor> void visit_each (const T_action& _A_action, const T_functor& _A_functor)
 This function performs a functor on each of the targets of a functor.

template <class T_type, class T_action, class T_functor> void visit_each_type (const T_action& _A_action, const T_functor& _A_functor)
 This function performs a functor on each of the targets of a functor limited to a restricted type.


Variables

const lambda<internal::lambda_select1_1
const lambda<internal::lambda_select2_2
const lambda<internal::lambda_select3_3
const lambda<internal::lambda_select4_4
const lambda<internal::lambda_select5_5
const lambda<internal::lambda_select6_6
const lambda<internal::lambda_select7_7


Function Documentation

template <class T_return, class T_functor>
bind_return_functor<typename unwrap_reference<T_return>::type, T_functor> bind_return ( const T_functor&  _A_functor,
T_return  _A_ret_value
[inline]
 

template <class T_setter, class T_getter1, class T_getter2>
compose2_functor<T_setter, T_getter1, T_getter2> compose ( const T_setter&  _A_setter,
const T_getter1&  _A_getter1,
const T_getter2&  _A_getter2
[inline]
 

template <class T_setter, class T_getter>
compose1_functor<T_setter, T_getter> compose ( const T_setter&  _A_setter,
const T_getter&  _A_getter
[inline]
 

template <class T_type>
lambda<T_type> constant ( const T_type&  v  ) 
 

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

template <class T_functor, class T_catcher>
exception_catch_functor<T_functor, T_catcher> exception_catch ( const T_functor&  _A_func,
const T_catcher&  _A_catcher
[inline]
 

template <class T_functor, class T_type1, class T_type2, class T_type3>
lambda<lambda_group3<T_functor, typename unwrap_reference<T_type1>::type,typename unwrap_reference<T_type2>::type,typename unwrap_reference<T_type3>::type> > group ( const T_functor&  _A_func,
T_type1  _A_1,
T_type2  _A_2,
T_type3  _A_3
 

template <class T_functor, class T_type1, class T_type2>
lambda<lambda_group2<T_functor, typename unwrap_reference<T_type1>::type,typename unwrap_reference<T_type2>::type> > group ( const T_functor&  _A_func,
T_type1  _A_1,
T_type2  _A_2
 

template <class T_functor, class T_type1>
lambda<lambda_group1<T_functor, typename unwrap_reference<T_type1>::type> > group ( const T_functor&  _A_func,
T_type1  _A_1
 

template <class T_functor>
retype_return_functor<void, T_functor> hide_return ( const T_functor&  _A_functor  )  [inline]
 

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& ( 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,
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&& ( 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,
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&= ( 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,
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* ( 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,
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*= ( 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,
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!= ( 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,
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% ( 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,
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%= ( 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,
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+ ( 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,
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+= ( 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,
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- ( 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,
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-= ( 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,
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/ ( 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,
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/= ( 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,
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< ( 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,
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<< ( 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,
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<<= ( 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,
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<= ( 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,
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== ( 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,
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> ( 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,
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>= ( 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,
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>> ( 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,
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>>= ( 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,
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^ ( 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,
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^= ( 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,
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| ( 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,
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|= ( 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,
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|| ( 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,
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>
const_reference_wrapper<T_type> ref ( const T_type&  v  ) 
 

template <class T_type>
reference_wrapper<T_type> ref ( T_type&  v  ) 
 

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

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
retype_functor<bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 > retype ( const bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
retype_functor<bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 > retype ( const bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
retype_functor<bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 > retype ( const bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
retype_functor<bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 > retype ( const bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
retype_functor<bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 > retype ( const bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2>
retype_functor<bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 > retype ( const bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1>
retype_functor<bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 > retype ( const bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj>
retype_functor<bound_const_volatile_mem_functor0<T_return, T_obj> > retype ( const bound_const_volatile_mem_functor0<T_return, T_obj>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
retype_functor<bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 > retype ( const bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
retype_functor<bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 > retype ( const bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
retype_functor<bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 > retype ( const bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
retype_functor<bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 > retype ( const bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
retype_functor<bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 > retype ( const bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2>
retype_functor<bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 > retype ( const bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1>
retype_functor<bound_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 > retype ( const bound_volatile_mem_functor1<T_return, T_obj, T_arg1>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj>
retype_functor<bound_volatile_mem_functor0<T_return, T_obj> > retype ( const bound_volatile_mem_functor0<T_return, T_obj>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
retype_functor<bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 > retype ( const bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
retype_functor<bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 > retype ( const bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
retype_functor<bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 > retype ( const bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
retype_functor<bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 > retype ( const bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
retype_functor<bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 > retype ( const bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2>
retype_functor<bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 > retype ( const bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1>
retype_functor<bound_const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 > retype ( const bound_const_mem_functor1<T_return, T_obj, T_arg1>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj>
retype_functor<bound_const_mem_functor0<T_return, T_obj> > retype ( const bound_const_mem_functor0<T_return, T_obj>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
retype_functor<bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 > retype ( const bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
retype_functor<bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 > retype ( const bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
retype_functor<bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 > retype ( const bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
retype_functor<bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 > retype ( const bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
retype_functor<bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 > retype ( const bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2>
retype_functor<bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 > retype ( const bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1>
retype_functor<bound_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 > retype ( const bound_mem_functor1<T_return, T_obj, T_arg1>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj>
retype_functor<bound_mem_functor0<T_return, T_obj> > retype ( const bound_mem_functor0<T_return, T_obj>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
retype_functor<const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 > retype ( const const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
retype_functor<const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 > retype ( const const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
retype_functor<const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 > retype ( const const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
retype_functor<const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 > retype ( const const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
retype_functor<const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 > retype ( const const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2>
retype_functor<const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 > retype ( const const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1>
retype_functor<const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 > retype ( const const_volatile_mem_functor1<T_return, T_obj, T_arg1>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj>
retype_functor<const_volatile_mem_functor0<T_return, T_obj> > retype ( const const_volatile_mem_functor0<T_return, T_obj>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
retype_functor<volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 > retype ( const volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
retype_functor<volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 > retype ( const volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
retype_functor<volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 > retype ( const volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
retype_functor<volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 > retype ( const volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
retype_functor<volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 > retype ( const volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2>
retype_functor<volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 > retype ( const volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1>
retype_functor<volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 > retype ( const volatile_mem_functor1<T_return, T_obj, T_arg1>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj>
retype_functor<volatile_mem_functor0<T_return, T_obj> > retype ( const volatile_mem_functor0<T_return, T_obj>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
retype_functor<const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 > retype ( const const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
retype_functor<const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 > retype ( const const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
retype_functor<const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 > retype ( const const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
retype_functor<const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 > retype ( const const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
retype_functor<const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 > retype ( const const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2>
retype_functor<const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 > retype ( const const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1>
retype_functor<const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 > retype ( const const_mem_functor1<T_return, T_obj, T_arg1>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj>
retype_functor<const_mem_functor0<T_return, T_obj> > retype ( const const_mem_functor0<T_return, T_obj>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
retype_functor<mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 > retype ( const mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
retype_functor<mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 > retype ( const mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
retype_functor<mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 > retype ( const mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
retype_functor<mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 > retype ( const mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
retype_functor<mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 > retype ( const mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1, class T_arg2>
retype_functor<mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 > retype ( const mem_functor2<T_return, T_obj, T_arg1, T_arg2>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj, class T_arg1>
retype_functor<mem_functor1<T_return, T_obj, T_arg1>, T_arg1 > retype ( const mem_functor1<T_return, T_obj, T_arg1>&  _A_functor  )  [inline]
 

template <class T_return, class T_obj>
retype_functor<mem_functor0<T_return, T_obj> > retype ( const mem_functor0<T_return, T_obj>&  _A_functor  )  [inline]
 

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return>
retype_functor<pointer_functor7<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 > retype ( const pointer_functor7<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return>&  _A_functor  )  [inline]
 

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return>
retype_functor<pointer_functor6<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 > retype ( const pointer_functor6<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return>&  _A_functor  )  [inline]
 

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return>
retype_functor<pointer_functor5<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 > retype ( const pointer_functor5<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return>&  _A_functor  )  [inline]
 

template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return>
retype_functor<pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>, T_arg1,T_arg2,T_arg3,T_arg4 > retype ( const pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>&  _A_functor  )  [inline]
 

template <class T_arg1, class T_arg2, class T_arg3, class T_return>
retype_functor<pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>, T_arg1,T_arg2,T_arg3 > retype ( const pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>&  _A_functor  )  [inline]
 

template <class T_arg1, class T_arg2, class T_return>
retype_functor<pointer_functor2<T_arg1, T_arg2, T_return>, T_arg1,T_arg2 > retype ( const pointer_functor2<T_arg1, T_arg2, T_return>&  _A_functor  )  [inline]
 

template <class T_arg1, class T_return>
retype_functor<pointer_functor1<T_arg1, T_return>, T_arg1 > retype ( const pointer_functor1<T_arg1, T_return>&  _A_functor  )  [inline]
 

template <class T_return>
retype_functor<pointer_functor0<T_return> > retype ( const pointer_functor0<T_return>&  _A_functor  )  [inline]
 

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
retype_functor<slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 > retype ( const slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>&  _A_functor  )  [inline]
 

template <class T_return, class T_functor>
retype_return_functor<T_return, T_functor> retype_return ( const T_functor&  _A_functor  )  [inline]
 

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

template <class T_type>
const T_type& unwrap ( const const_reference_wrapper<T_type>&  v  ) 
 

template <class T_type>
T_type& unwrap ( const reference_wrapper<T_type>&  v  ) 
 

template <class T_type>
const T_type& unwrap ( const T_type&  v  ) 
 

template <class T_type>
T_type& unwrap ( T_type&  v  ) 
 

template <class T_type>
lambda<const T_type&> var ( const T_type&  v  ) 
 

template <class T_type>
lambda<T_type&> var ( T_type&  v  ) 
 

template <class T_action, class T_functor>
void visit_each ( const T_action&  _A_action,
const T_functor&  _A_functor
 

This function performs a functor on each of the targets of a functor.

All unknown types just call _A_action on them. Add overloads that specialize the T_functor argument for your own functor types, so that subobjects get visited. This is needed to enable auto-disconnection support for your functor types.

Example:
   struct some_functor
   {
     void operator()() {}
     some_possibly_sigc_trackable_derived_type some_data_member;
     some_other_functor_type some_other_functor;
   }

   namespace sigc
   {
     template <class T_action>
     void visit_each(const T_action& _A_action,
                     const some_functor& _A_target)
     {
       visit_each(_A_action, _A_target.some_data_member);
       visit_each(_A_action, _A_target.some_other_functor);
     }
   }

template <class T_action, class T_return, class T_functor>
void visit_each ( const T_action&  _A_action,
const retype_return_functor<T_return, T_functor>&  _A_target
 

template <class T_action, class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6, class T_type7>
void visit_each ( const T_action&  _A_action,
const retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>&  _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_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
 

template <class T_action, class T_functor, class T_type1, class T_type2, class T_type3>
void visit_each ( const T_action&  _A_action,
const lambda_group3<T_functor, T_type1, T_type2, T_type3>&  _A_target
 

template <class T_action, class T_functor, class T_type1, class T_type2>
void visit_each ( const T_action&  _A_action,
const lambda_group2<T_functor, T_type1, T_type2>&  _A_target
 

template <class T_action, class T_functor, class T_type1>
void visit_each ( const T_action&  _A_action,
const lambda_group1<T_functor, T_type1>&  _A_target
 

template <class T_action, class T_type>
void visit_each ( const T_action&  _A_action,
const lambda<T_type>&  _A_target
 

template <class T_action, class T_functor, bool I_islambda>
void visit_each ( const T_action&  _A_action,
const internal::lambda_core<T_functor, I_islambda>&  _A_target
 

template <class T_action, class T_functor, class T_catcher, class T_return>
void visit_each ( const T_action&  _A_action,
const exception_catch_functor<T_functor, T_catcher, T_return>&  _A_target
 

template <class T_action, class T_setter, class T_getter1, class T_getter2>
void visit_each ( const T_action&  _A_action,
const compose2_functor<T_setter, T_getter1, T_getter2>&  _A_target
 

template <class T_action, class T_setter, class T_getter>
void visit_each ( const T_action&  _A_action,
const compose1_functor<T_setter, T_getter>&  _A_target
 

template <class T_action, class T_return, class T_functor>
void visit_each ( const T_action&  _A_action,
const bind_return_functor<T_return, T_functor>&  _A_target
 

template <class T_type, class T_action, class T_functor>
void visit_each_type ( const T_action&  _A_action,
const T_functor&  _A_functor
 

This function performs a functor on each of the targets of a functor limited to a restricted type.


Variable Documentation

const lambda<internal::lambda_select1> sigc::_1
 

const lambda<internal::lambda_select2> sigc::_2
 

const lambda<internal::lambda_select3> sigc::_3
 

const lambda<internal::lambda_select4> sigc::_4
 

const lambda<internal::lambda_select5> sigc::_5
 

const lambda<internal::lambda_select6> sigc::_6
 

const lambda<internal::lambda_select7> sigc::_7
 


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