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, 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, 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, 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, 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, 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
| Adaptor that fixes the return value of the wrapped functor. More...
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
| Adaptor that combines two functors. More...
struct | compose1_functor.deduce_result_type
struct | compose2_functor
| Adaptor that combines three functors. More...
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
| Const reference wrapper. More...
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
| Reference wrapper. More...
struct | reinterpret_
struct | relational
struct | retype_functor
| Adaptor that performs C-style casts on the parameters passed on to the functor. More...
struct | retype_functor.deduce_result_type
struct | retype_return_functor
| Adaptor that perform a C-style cast on the return value of a functor. More...
struct | retype_return_functor.deduce_result_type
struct | retype_return_functor<void, T_functor>
| Adaptor that perform a C-style cast on the return value of a functor. More...
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)
| Performs a functor on each of the targets of a functor.
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)
| Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed functor to the passed argument.
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)
| Performs a functor on each of the targets of a functor.
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)
| Performs a functor on each of the targets of a functor.
template <class T_setter, class T_getter> compose1_functor< T_setter, T_getter > | compose (const T_setter& _A_setter, const T_getter& _A_getter)
| Creates an adaptor of type sigc::compose1_functor which combines two functors.
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)
| Creates an adaptor of type sigc::compose2_functor which combines three functors.
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)
| Performs a functor on each of the targets of a functor.
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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
template <class T_return> retype_functor< pointer_functor0< T_return > > | retype (const pointer_functor0<T_return>& _A_functor)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)

| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)

| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)

| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)

| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)

| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)

| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)

| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)

| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)

| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)

| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)

| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the 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)
| Performs a functor on each of the targets of a functor.
template <class T_return, class T_functor> retype_return_functor< T_return, T_functor > | retype_return (const T_functor& _A_functor)
| Creates an adaptor of type sigc::retype_return_functor which performs a C-style cast on the return value of the passed functor.
template <class T_functor> retype_return_functor< void, T_functor > | hide_return (const T_functor& _A_functor)
| Creates an adaptor of type sigc::retype_return_functor which drops the return value of the passed 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)
| Creates a reference wrapper.
template <class T_type> const_reference_wrapper<T_type> | ref (const T_type& v)
| Creates a const reference wrapper.
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_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_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 | ) |

Creates a const reference wrapper.

Passing an object throught sigc::ref() makes libsigc++ adaptors like, e.g., sigc::bind store references to the object instead of copies. If the object type inherits from sigc::trackable this will ensure automatic invalidation of the adaptors when the object is deleted or overwritten.

Parameters:

  v | Reference to store.

Returns:
  A reference wrapper.

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

Creates a reference wrapper.

Passing an object throught sigc::ref() makes libsigc++ adaptors like, e.g., sigc::bind store references to the object instead of copies. If the object type inherits from sigc::trackable this will ensure automatic invalidation of the adaptors when the object is deleted or overwritten.

Parameters:

  v | Reference to store.

Returns:
  A reference wrapper.

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>
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_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
| ) |

## 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