---

sigc Namespace Reference

Classes
struct	adaptor_functor
	Converts an arbitrary functor into an adaptor type. More...
struct	adaptor_trait<T_functor, true>
	Trait that specifies what is the adaptor version of a functor type. More...
struct	adaptor_trait<T_functor, false>
	Trait that specifies what is the adaptor version of a functor type. More...
struct	adapts
	Base type for adaptors. More...
struct	bind_functor<0, T_functor, T_bound, nil, nil, nil, nil, nil, nil>
	Adaptor that binds an argument to the wrapped functor. More...
struct	bind_functor<1, T_functor, T_bound, nil, nil, nil, nil, nil, nil>
	Adaptor that binds an argument to the wrapped functor. More...
struct	bind_functor<2, T_functor, T_bound, nil, nil, nil, nil, nil, nil>
	Adaptor that binds an argument to the wrapped functor. More...
struct	bind_functor<3, T_functor, T_bound, nil, nil, nil, nil, nil, nil>
	Adaptor that binds an argument to the wrapped functor. More...
struct	bind_functor<4, T_functor, T_bound, nil, nil, nil, nil, nil, nil>
	Adaptor that binds an argument to the wrapped functor. More...
struct	bind_functor<5, T_functor, T_bound, nil, nil, nil, nil, nil, nil>
	Adaptor that binds an argument to the wrapped functor. More...
struct	bind_functor<6, T_functor, T_bound, nil, nil, nil, nil, nil, nil>
	Adaptor that binds an argument to the wrapped functor. More...
struct	bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil >
	Adaptor that binds 1 argument(s) to the wrapped functor. More...
struct	bind_functor<-1, T_functor, T_type1, T_type2, nil, nil, nil, nil, nil >
	Adaptor that binds 2 argument(s) to the wrapped functor. More...
struct	bind_functor<-1, T_functor, T_type1, T_type2, T_type3, nil, nil, nil, nil >
	Adaptor that binds 3 argument(s) to the wrapped functor. More...
struct	bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, nil, nil, nil >
	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, T_type5, nil, nil >
	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, T_type6, nil >
	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, T_type7 >
	Adaptor that binds 7 argument(s) to the wrapped functor. More...
struct	bind_return_functor
	Adaptor that fixes the return value of the wrapped functor. More...
class	bound_argument
	A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return()) argument. More...
class	bound_argument<reference_wrapper<T_wrapped>>
	bound_argument object for a bound argument that is passed by bind() or returned by bind_return() by reference, specialized for reference_wrapper<> types. More...
class	bound_argument<const_reference_wrapper<T_wrapped>>
	bound_argument object for a bound argument that is passed by bind() or returned by bind_return() by const reference, specialized for const reference_wrapper<> types. More...
struct	compose1_functor
	Adaptor that combines two functors. More...
struct	compose2_functor
	Adaptor that combines three functors. More...
struct	adaptor_base
	A hint to the compiler. More...
struct	deduce_result_type
	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	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, 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, 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, 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, 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, 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, T_arg6, T_arg7, true>
	Deduce the return type of a functor. More...
struct	exception_catch_functor
struct	exception_catch_functor<T_functor, T_catcher, void>
struct	hide_functor<-1, T_functor >
	Adaptor that adds a dummy parameter to the wrapped functor. More...
struct	hide_functor<0, T_functor>
	Adaptor that adds a dummy parameter to the wrapped functor. More...
struct	hide_functor<1, T_functor>
	Adaptor that adds a dummy parameter to the wrapped functor. More...
struct	hide_functor<2, T_functor>
	Adaptor that adds a dummy parameter to the wrapped functor. More...
struct	hide_functor<3, T_functor>
	Adaptor that adds a dummy parameter to the wrapped functor. More...
struct	hide_functor<4, T_functor>
	Adaptor that adds a dummy parameter to the wrapped functor. More...
struct	hide_functor<5, T_functor>
	Adaptor that adds a dummy parameter to the wrapped functor. More...
struct	hide_functor<6, T_functor>
	Adaptor that adds a dummy parameter to the wrapped functor. More...
struct	lambda_base
	A hint to the compiler. More...
struct	lambda
	Lambda type. More...
struct	unwrap_lambda_type
	Deduces the type of the object stored in an object of the passed lambda type. More...
struct	unwrap_lambda_type<lambda<T_type>>
struct	lambda_group1
struct	lambda_group2
struct	lambda_group3
struct	dereference_trait
	Deduces the base type of a reference or a pointer. More...
struct	dereference_trait<T_type*>
struct	dereference_trait<const T_type*>
struct	dereference_trait<T_type*&>
struct	dereference_trait<const T_type*&>
struct	dereference_trait<T_type* const&>
struct	dereference_trait<const T_type* const&>
struct	arithmetic
struct	bitwise
struct	logical
struct	relational
struct	arithmetic_assign
struct	bitwise_assign
struct	other
struct	unary_arithmetic
struct	unary_bitwise
struct	unary_logical
struct	unary_other
struct	cast_
struct	plus
struct	minus
struct	multiplies
struct	divides
struct	modulus
struct	leftshift
struct	rightshift
struct	and_
struct	or_
struct	xor_
struct	less
struct	greater
struct	less_equal
struct	greater_equal
struct	equal_to
struct	not_equal_to
struct	subscript
struct	assign
struct	pre_increment
struct	pre_decrement
struct	negate
struct	not_
struct	address
struct	dereference
struct	reinterpret_
struct	static_
struct	dynamic_
struct	lambda_action_deduce_result_type
struct	lambda_action_deduce_result_type<logical<T_action>, T_test1, T_test2>
struct	lambda_action_deduce_result_type<relational<T_action>, T_test1, T_test2>
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<other<subscript>, T_test1, T_test2>
struct	lambda_action_unary_deduce_result_type
struct	lambda_action_convert_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_action
struct	lambda_action_unary
struct	lambda_action_convert
struct	lambda_action<arithmetic<plus>>
struct	lambda_action<arithmetic<minus>>
struct	lambda_action<arithmetic<multiplies>>
struct	lambda_action<arithmetic<divides>>
struct	lambda_action<arithmetic<modulus>>
struct	lambda_action<bitwise<leftshift>>
struct	lambda_action<bitwise<rightshift>>
struct	lambda_action<bitwise<and_>>
struct	lambda_action<bitwise<or_>>
struct	lambda_action<bitwise<xor_>>
struct	lambda_action<logical<and_>>
struct	lambda_action<logical<or_>>
struct	lambda_action<relational<less>>
struct	lambda_action<relational<greater>>
struct	lambda_action<relational<less_equal>>
struct	lambda_action<relational<greater_equal>>
struct	lambda_action<relational<equal_to>>
struct	lambda_action<relational<not_equal_to>>
struct	lambda_action<arithmetic_assign<plus>>
struct	lambda_action<arithmetic_assign<minus>>
struct	lambda_action<arithmetic_assign<multiplies>>
struct	lambda_action<arithmetic_assign<divides>>
struct	lambda_action<arithmetic_assign<modulus>>
struct	lambda_action<bitwise_assign<leftshift>>
struct	lambda_action<bitwise_assign<rightshift>>
struct	lambda_action<bitwise_assign<and_>>
struct	lambda_action<bitwise_assign<or_>>
struct	lambda_action<bitwise_assign<xor_>>
struct	lambda_action<other<subscript>>
struct	lambda_action<other<assign>>
struct	lambda_action_unary<unary_arithmetic<pre_increment>>
struct	lambda_action_unary<unary_arithmetic<pre_decrement>>
struct	lambda_action_unary<unary_arithmetic<negate>>
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_convert<cast_<reinterpret_>, T_type>
struct	lambda_action_convert<cast_<static_>, T_type>
struct	lambda_action_convert<cast_<dynamic_>, T_type>
struct	lambda_operator
struct	lambda_operator_unary
struct	lambda_operator_convert
struct	retype_functor
	Adaptor that performs C-style casts on the parameters passed on to the functor. More...
struct	retype_return_functor
	Adaptor that perform a C-style cast on the return value of a functor. More...
struct	retype_return_functor<void, T_functor>
	Adaptor that perform a C-style cast on the return value of a functor. More...
struct	connection
	Convinience class for safe disconnection. More...
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>
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...
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...
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...
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...
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_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_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...
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	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...
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
	Convenience wrapper for the numbered sigc::slot# templates. More...
class	slot<T_return, nil, nil, nil, nil, nil, nil, nil>
	Convenience wrapper for the numbered sigc::slot0 template. More...
class	slot<T_return, T_arg1, nil, nil, nil, nil, nil, nil>
	Convenience wrapper for the numbered sigc::slot1 template. More...
class	slot<T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil>
	Convenience wrapper for the numbered sigc::slot2 template. More...
class	slot<T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil>
	Convenience wrapper for the numbered sigc::slot3 template. More...
class	slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil>
	Convenience wrapper for the numbered sigc::slot4 template. More...
class	slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil>
	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, nil>
	Convenience wrapper for the numbered sigc::slot6 template. More...
class	slot_base
	Base type for slots. More...
class	limit_reference
	A limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the sigc::trackable reference instead of the derived reference. More...
class	limit_reference<T_type, true>
	limit_reference object for a class that derives from trackable. More...
class	const_limit_reference
	A const_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the sigc::trackable reference instead of the derived reference. More...
class	const_limit_reference<T_type, true>
	const_limit_reference object for a class that derives from trackable. More...
class	volatile_limit_reference
	A volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the sigc::trackable reference instead of the derived reference. More...
class	volatile_limit_reference<T_type, true>
	volatile_limit_reference object for a class that derives from trackable. More...
class	const_volatile_limit_reference
	A const_volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that, if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the sigc::trackable reference instead of the derived reference. More...
class	const_volatile_limit_reference<T_type, true>
	const_volatile_limit_reference object for a class that derives from trackable. More...
struct	reference_wrapper
	Reference wrapper. More...
struct	const_reference_wrapper
	Const reference wrapper. More...
struct	unwrap_reference
struct	unwrap_reference<reference_wrapper<T_type>>
struct	unwrap_reference<const_reference_wrapper<T_type>>
struct	slot_iterator
	STL-style iterator for slot_list. More...
struct	slot_const_iterator
	STL-style const iterator for slot_list. More...
struct	slot_list
	STL-style list interface for sigc::signal#. 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
	Convenience wrapper for the numbered sigc::signal# templates. More...
class	signal<T_return, nil, nil, nil, nil, nil, nil, nil>
	Convenience wrapper for the numbered sigc::signal0 template. More...
class	signal<T_return, T_arg1, nil, nil, nil, nil, nil, nil>
	Convenience wrapper for the numbered sigc::signal1 template. More...
class	signal<T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil>
	Convenience wrapper for the numbered sigc::signal2 template. More...
class	signal<T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil>
	Convenience wrapper for the numbered sigc::signal3 template. More...
class	signal<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil>
	Convenience wrapper for the numbered sigc::signal4 template. More...
class	signal<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil>
	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, nil>
	Convenience wrapper for the numbered sigc::signal6 template. More...
struct	signal_base
	Base class for the sigc::signal# templates. More...
struct	trackable
	Base class for objects with auto-disconnection. More...
struct	type_trait
struct	type_trait< T_type[N]>
struct	type_trait<T_type&>
struct	type_trait<const T_type&>
struct	type_trait<void>
struct	is_base_and_derived
	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<T_base, T_base>
struct	functor_trait<T_return(T_obj::*)(), false>
struct	functor_trait<T_return(T_obj::*)() const, false>
struct	functor_trait<T_return(T_obj::*)(T_arg1), false>
struct	functor_trait<T_return(T_obj::*)(T_arg1) 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) 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) 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) 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) 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) 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	functor_trait<T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const, false>
Namespaces
namespace	internal
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, T_bound1 >	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, T_type1 >	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, T_type1, T_type2 >	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, T_type1, T_type2, T_type3 >	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, T_type1, T_type2, T_type3, T_type4 >	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, T_type1, T_type2, T_type3, T_type4, T_type5 >	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, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6 >	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, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >	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 < T_return, 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_type>
void	visit_each (const T_action& _A_action, const bound_argument<T_type>& _A_argument)
	Implementation of visit_each() specialized for the bound_argument class.
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&>	var (T_type& v)
	Converts a reference into a lambda object.
template<class T_type>
lambda<const T_type&>	var (const T_type& v)
	Converts a constant reference into a lambda object.
template<class T_type>
T_type&	unwrap_lambda_value (T_type& a)
	Gets the object stored inside a lambda object.
template<class T_type>
const T_type&	unwrap_lambda_value (const T_type& a)
template<class T_type>
const T_type&	unwrap_lambda_value (const lambda<T_type>& a)
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, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic<plus>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator+ (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic<minus>, T_arg1, T_arg2 > >	operator- (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic<minus>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator- (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic<minus>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator- (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic <multiplies>, T_arg1, T_arg2 > >	operator* (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic <multiplies>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator* (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic <multiplies>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator* (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic<divides>, T_arg1, T_arg2 > >	operator/ (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic<divides>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator/ (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic<divides>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator/ (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic<modulus>, T_arg1, T_arg2 > >	operator% (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic<modulus>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator% (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic<modulus>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator% (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise<leftshift>, T_arg1, T_arg2 > >	operator<< (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise<leftshift>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator<< (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise<leftshift>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator<< (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise<rightshift>, T_arg1, T_arg2 > >	operator>> (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise<rightshift>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator>> (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise<rightshift>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator>> (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise<and_>, T_arg1, T_arg2 > >	operator& (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise<and_>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator& (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise<and_>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator& (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise<or_>, T_arg1, T_arg2 > >	operator| (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise<or_>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator| (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise<or_>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator| (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise<xor_>, T_arg1, T_arg2 > >	operator^ (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise<xor_>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator^ (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise<xor_>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator^ (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <logical<and_>, T_arg1, T_arg2 > >	operator&& (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <logical<and_>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator&& (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <logical<and_>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator&& (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <logical<or_>, T_arg1, T_arg2 > >	operator|| (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <logical<or_>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator|| (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <logical<or_>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator|| (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <relational<less>, T_arg1, T_arg2 > >	operator< (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <relational<less>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator< (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <relational<less>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator< (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <relational<greater>, T_arg1, T_arg2 > >	operator> (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <relational<greater>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator> (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <relational<greater>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator> (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <relational <less_equal>, T_arg1, T_arg2 > >	operator<= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <relational <less_equal>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator<= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <relational <less_equal>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator<= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <relational <greater_equal>, T_arg1, T_arg2 > >	operator>= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <relational <greater_equal>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator>= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <relational <greater_equal>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator>= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <relational <equal_to>, T_arg1, T_arg2 > >	operator== (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <relational <equal_to>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator== (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <relational <equal_to>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator== (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <relational <not_equal_to>, T_arg1, T_arg2 > >	operator!= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <relational <not_equal_to>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator!= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <relational <not_equal_to>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator!= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic_assign <plus>, T_arg1, T_arg2 > >	operator+= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic_assign <plus>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator+= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic_assign <plus>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator+= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic_assign <minus>, T_arg1, T_arg2 > >	operator-= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic_assign <minus>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator-= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic_assign <minus>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator-= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic_assign <multiplies>, T_arg1, T_arg2 > >	operator*= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic_assign <multiplies>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator*= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic_assign <multiplies>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator*= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic_assign <divides>, T_arg1, T_arg2 > >	operator/= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic_assign <divides>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator/= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic_assign <divides>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator/= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic_assign <modulus>, T_arg1, T_arg2 > >	operator%= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic_assign <modulus>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator%= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <arithmetic_assign <modulus>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator%= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise_assign <leftshift>, T_arg1, T_arg2 > >	operator<<= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise_assign <leftshift>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator<<= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise_assign <leftshift>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator<<= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise_assign <rightshift>, T_arg1, T_arg2 > >	operator>>= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise_assign <rightshift>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator>>= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise_assign <rightshift>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator>>= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise_assign <and_>, T_arg1, T_arg2 > >	operator&= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise_assign <and_>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator&= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise_assign <and_>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator&= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise_assign<or_>, T_arg1, T_arg2 > >	operator|= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise_assign<or_>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator|= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise_assign<or_>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator|= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise_assign <xor_>, T_arg1, T_arg2 > >	operator^= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise_assign <xor_>, T_arg1, typename unwrap_reference <T_arg2 >::type >>	operator^= (const lambda<T_arg1>& a1, const T_arg2& a2)
template<class T_arg1, class T_arg2>
lambda < lambda_operator <bitwise_assign <xor_>, typename unwrap_reference < T_arg1 >::type, T_arg2 > >	operator^= (const T_arg1& a1, const lambda<T_arg2>& a2)
template<class T_arg>
lambda < lambda_operator_unary < unary_arithmetic <pre_increment>, T_arg > >	operator++ (const lambda<T_arg>& a)
template<class T_arg>
lambda < lambda_operator_unary < unary_arithmetic <pre_decrement>, T_arg > >	operator-- (const lambda<T_arg>& a)
template<class T_arg>
lambda < lambda_operator_unary < unary_arithmetic <negate >, T_arg >>	operator- (const lambda<T_arg>& a)
template<class T_arg>
lambda < lambda_operator_unary < unary_bitwise <not_ >, T_arg >>	operator~ (const lambda<T_arg>& a)
template<class T_arg>
lambda < lambda_operator_unary < unary_logical <not_ >, T_arg >>	operator! (const lambda<T_arg>& a)
template<class T_arg>
lambda < lambda_operator_unary < unary_other <address >, T_arg >>	operator& (const lambda<T_arg>& a)
template<class T_arg>
lambda < lambda_operator_unary < unary_other <dereference>, T_arg > >	operator* (const lambda<T_arg>& a)
template<class T_type, class T_arg>
lambda < lambda_operator_convert < cast_ <reinterpret_>, T_type, typename unwrap_lambda_type <T_arg >::type >>	reinterpret_cast_ (const T_arg& a)
template<class T_type, class T_arg>
lambda < lambda_operator_convert < cast_<static_>, T_type, typename unwrap_lambda_type <T_arg >::type >>	static_cast_ (const T_arg& a)
template<class T_type, class T_arg>
lambda < lambda_operator_convert < cast_<dynamic_>, T_type, typename unwrap_lambda_type <T_arg >::type >>	dynamic_cast_ (const T_arg& a)
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, 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_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_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_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_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>
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, 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_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_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_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_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>
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_action, class T_type, bool I_derives_trackable>
void	visit_each (const T_action& _A_action, const limit_reference<T_type, I_derives_trackable>& _A_target)
	Implementation of visit_each() specialized for the limit_reference class, to call visit_each() on the entity returned by the limit_reference's visit() method.
template<class T_action, class T_type, bool I_derives_trackable>
void	visit_each (const T_action& _A_action, const const_limit_reference<T_type, I_derives_trackable>& _A_target)
	Implementation of visit_each() specialized for the const_limit_reference class, to call visit_each() on the entity returned by the const_limit_reference's visit() method.
template<class T_action, class T_type, bool I_derives_trackable>
void	visit_each (const T_action& _A_action, const volatile_limit_reference<T_type, I_derives_trackable>& _A_target)
	Implementation of visit_each() specialized for the volatile_limit_reference class, to call visit_each() on the entity returned by the volatile_limit_reference's visit() method.
template<class T_action, class T_type, bool I_derives_trackable>
void	visit_each (const T_action& _A_action, const const_volatile_limit_reference<T_type, I_derives_trackable>& _A_target)
	Implementation of visit_each() specialized for the const_volatile_limit_reference class, to call visit_each() on the entity returned by the const_volatile_limit_reference's visit() method.
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 (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
SIGC_API const lambda <internal::lambda_select1>	_1
SIGC_API const lambda <internal::lambda_select2>	_2
SIGC_API const lambda <internal::lambda_select3>	_3
SIGC_API const lambda <internal::lambda_select4>	_4
SIGC_API const lambda <internal::lambda_select5>	_5
SIGC_API const lambda <internal::lambda_select6>	_6
SIGC_API const lambda <internal::lambda_select7>	_7

---

Function Documentation

template <class T_type, class T_arg>

lambda<lambda_operator_convert<cast_<dynamic_>, T_type, typename unwrap_lambda_type<T_arg>::type> > sigc::dynamic_cast_

(

const T_arg &

a

)

[inline]

template <class T_functor, class T_catcher>

exception_catch_functor<T_functor, T_catcher> sigc::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> > sigc::group	(	const T_functor &	_A_func,
		T_type1	_A_1,
		T_type2	_A_2,
		T_type3	_A_3
	)			[inline]

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> > sigc::group	(	const T_functor &	_A_func,
		T_type1	_A_1,
		T_type2	_A_2
	)			[inline]

template <class T_functor, class T_type1>

lambda<lambda_group1<T_functor, typename unwrap_reference<T_type1>::type> > sigc::group	(	const T_functor &	_A_func,
		T_type1	_A_1
	)			[inline]

template <class T_arg>

lambda<lambda_operator_unary<unary_other<address>, T_arg> > sigc::operator&

(

const lambda< T_arg > &

a

)

[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise<and_>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator&	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise<and_>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator&	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise<and_>, T_arg1, T_arg2> > sigc::operator&	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<logical<and_>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator&&	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<logical<and_>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator&&	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<logical<and_>, T_arg1, T_arg2> > sigc::operator&&	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise_assign<and_>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator&=	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise_assign<and_>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator&=	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise_assign<and_>, T_arg1, T_arg2> > sigc::operator&=	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg>

lambda<lambda_operator_unary<unary_other<dereference>, T_arg> > sigc::operator*

(

const lambda< T_arg > &

a

)

[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic<multiplies>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator*	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic<multiplies>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator*	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic<multiplies>, T_arg1, T_arg2> > sigc::operator*	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic_assign<multiplies>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator*=	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic_assign<multiplies>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator*=	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic_assign<multiplies>, T_arg1, T_arg2> > sigc::operator*=	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg>

lambda<lambda_operator_unary<unary_logical<not_>, T_arg> > sigc::operator!

(

const lambda< T_arg > &

a

)

[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<relational<not_equal_to>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator!=	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<relational<not_equal_to>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator!=	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<relational<not_equal_to>, T_arg1, T_arg2> > sigc::operator!=	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic<modulus>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator%	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic<modulus>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator%	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic<modulus>, T_arg1, T_arg2> > sigc::operator%	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic_assign<modulus>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator%=	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic_assign<modulus>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator%=	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic_assign<modulus>, T_arg1, T_arg2> > sigc::operator%=	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic<plus>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator+	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic<plus>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator+	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic<plus>, T_arg1, T_arg2> > sigc::operator+	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg>

lambda<lambda_operator_unary<unary_arithmetic<pre_increment>, T_arg> > sigc::operator++

(

const lambda< T_arg > &

a

)

[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic_assign<plus>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator+=	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic_assign<plus>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator+=	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic_assign<plus>, T_arg1, T_arg2> > sigc::operator+=	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg>

lambda<lambda_operator_unary<unary_arithmetic<negate>, T_arg> > sigc::operator-

(

const lambda< T_arg > &

a

)

[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic<minus>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator-	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic<minus>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator-	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic<minus>, T_arg1, T_arg2> > sigc::operator-	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg>

lambda<lambda_operator_unary<unary_arithmetic<pre_decrement>, T_arg> > sigc::operator--

(

const lambda< T_arg > &

a

)

[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic_assign<minus>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator-=	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic_assign<minus>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator-=	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic_assign<minus>, T_arg1, T_arg2> > sigc::operator-=	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic<divides>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator/	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic<divides>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator/	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic<divides>, T_arg1, T_arg2> > sigc::operator/	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic_assign<divides>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator/=	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic_assign<divides>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator/=	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<arithmetic_assign<divides>, T_arg1, T_arg2> > sigc::operator/=	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<relational<less>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator<	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<relational<less>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator<	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<relational<less>, T_arg1, T_arg2> > sigc::operator<	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise<leftshift>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator<<	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise<leftshift>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator<<	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise<leftshift>, T_arg1, T_arg2> > sigc::operator<<	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise_assign<leftshift>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator<<=	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise_assign<leftshift>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator<<=	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise_assign<leftshift>, T_arg1, T_arg2> > sigc::operator<<=	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<relational<less_equal>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator<=	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<relational<less_equal>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator<=	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<relational<less_equal>, T_arg1, T_arg2> > sigc::operator<=	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<relational<equal_to>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator==	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<relational<equal_to>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator==	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<relational<equal_to>, T_arg1, T_arg2> > sigc::operator==	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<relational<greater>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator>	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<relational<greater>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator>	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<relational<greater>, T_arg1, T_arg2> > sigc::operator>	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<relational<greater_equal>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator>=	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<relational<greater_equal>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator>=	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<relational<greater_equal>, T_arg1, T_arg2> > sigc::operator>=	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise<rightshift>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator>>	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise<rightshift>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator>>	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise<rightshift>, T_arg1, T_arg2> > sigc::operator>>	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise_assign<rightshift>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator>>=	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise_assign<rightshift>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator>>=	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise_assign<rightshift>, T_arg1, T_arg2> > sigc::operator>>=	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise<xor_>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator^	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise<xor_>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator^	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise<xor_>, T_arg1, T_arg2> > sigc::operator^	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise_assign<xor_>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator^=	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise_assign<xor_>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator^=	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise_assign<xor_>, T_arg1, T_arg2> > sigc::operator^=	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise<or_>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator|	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise<or_>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator|	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise<or_>, T_arg1, T_arg2> > sigc::operator|	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise_assign<or_>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator|=	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise_assign<or_>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator|=	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<bitwise_assign<or_>, T_arg1, T_arg2> > sigc::operator|=	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<logical<or_>, typename unwrap_reference<T_arg1>::type, T_arg2> > sigc::operator||	(	const T_arg1 &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<logical<or_>, T_arg1, typename unwrap_reference<T_arg2>::type> > sigc::operator||	(	const lambda< T_arg1 > &	a1,
		const T_arg2 &	a2
	)			[inline]

template <class T_arg1, class T_arg2>

lambda<lambda_operator<logical<or_>, T_arg1, T_arg2> > sigc::operator||	(	const lambda< T_arg1 > &	a1,
		const lambda< T_arg2 > &	a2
	)			[inline]

template <class T_arg>

lambda<lambda_operator_unary<unary_bitwise<not_>, T_arg> > sigc::operator~

(

const lambda< T_arg > &

a

)

[inline]

template <class T_type>

const_reference_wrapper<T_type> sigc::ref

(

const T_type &

v

)

[inline]

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> sigc::ref

(

T_type &

v

)

[inline]

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, typename unwrap_lambda_type<T_arg>::type> > sigc::reinterpret_cast_

(

const T_arg &

a

)

[inline]

template <class T_type, class T_arg>

lambda<lambda_operator_convert<cast_<static_>, T_type, typename unwrap_lambda_type<T_arg>::type> > sigc::static_cast_

(

const T_arg &

a

)

[inline]

template <class T_type>

const T_type& sigc::unwrap

(

const const_reference_wrapper< T_type > &

v

)

[inline]

template <class T_type>

T_type& sigc::unwrap

(

const reference_wrapper< T_type > &

v

)

[inline]

template <class T_type>

const T_type& sigc::unwrap_lambda_value

(

const lambda< T_type > &

a

)

[inline]

template <class T_type>

const T_type& sigc::unwrap_lambda_value

(

const T_type &

a

)

[inline]

template <class T_type>

T_type& sigc::unwrap_lambda_value

(

T_type &

a

)

[inline]

Gets the object stored inside a lambda object.

Returns the object passed as argument if it is not of type lambda.

template <class T_type>

lambda<const T_type&> sigc::var

(

const T_type &

v

)

[inline]

Converts a constant reference into a lambda object.

template <class T_type>

lambda<T_type&> sigc::var

(

T_type &

v

)

[inline]

Converts a reference into a lambda object.

sigc::var creates a 0-ary functor, returning the value of a referenced variable.

Example:

   int main(int argc, char* argv)
   {
     int data;
     sigc::signal<int> readValue;

     readValue.connect(sigc::var(data));

     data = 3;
     std::cout << readValue() << std::endl; //Prints 3.

    data = 5;
    std::cout << readValue() << std::endl; //Prints 5.
   }

template <class T_action, class T_type, bool I_derives_trackable>

void sigc::visit_each	(	const T_action &	_A_action,
		const const_volatile_limit_reference< T_type, I_derives_trackable > &	_A_target
	)			[inline]

Implementation of visit_each() specialized for the const_volatile_limit_reference class, to call visit_each() on the entity returned by the const_volatile_limit_reference's visit() method.

• T_action The type of functor to invoke.
• T_type The type of the reference.

  Parameters:

  	_A_action	The functor to invoke.
  	_A_argument	The visited instance.

template <class T_action, class T_type, bool I_derives_trackable>

void sigc::visit_each	(	const T_action &	_A_action,
		const volatile_limit_reference< T_type, I_derives_trackable > &	_A_target
	)			[inline]

Implementation of visit_each() specialized for the volatile_limit_reference class, to call visit_each() on the entity returned by the volatile_limit_reference's visit() method.

• T_action The type of functor to invoke.
• T_type The type of the reference.

  Parameters:

  	_A_action	The functor to invoke.
  	_A_argument	The visited instance.

template <class T_action, class T_type, bool I_derives_trackable>

void sigc::visit_each	(	const T_action &	_A_action,
		const const_limit_reference< T_type, I_derives_trackable > &	_A_target
	)			[inline]

Implementation of visit_each() specialized for the const_limit_reference class, to call visit_each() on the entity returned by the const_limit_reference's visit() method.

• T_action The type of functor to invoke.
• T_type The type of the reference.

  Parameters:

  	_A_action	The functor to invoke.
  	_A_argument	The visited instance.

template <class T_action, class T_type, bool I_derives_trackable>

void sigc::visit_each	(	const T_action &	_A_action,
		const limit_reference< T_type, I_derives_trackable > &	_A_target
	)			[inline]

Implementation of visit_each() specialized for the limit_reference class, to call visit_each() on the entity returned by the limit_reference's visit() method.

• T_action The type of functor to invoke.
• T_type The type of the reference.

  Parameters:

  	_A_action	The functor to invoke.
  	_A_argument	The visited instance.

template <class T_action, class T_lambda_action, class T_type, class T_arg>

void sigc::visit_each	(	const T_action &	_A_action,
		const lambda_operator_convert< T_lambda_action, T_type, T_arg > &	_A_target
	)			[inline]

template <class T_action, class T_lambda_action, class T_arg>

void sigc::visit_each	(	const T_action &	_A_action,
		const lambda_operator_unary< T_lambda_action, T_arg > &	_A_target
	)			[inline]

template <class T_action, class T_lambda_action, class T_arg1, class T_arg2>

void sigc::visit_each	(	const T_action &	_A_action,
		const lambda_operator<T_lambda_action, T_arg1, T_arg2 > &	_A_target
	)			[inline]

template <class T_action, class T_functor, class T_type1, class T_type2, class T_type3>

void sigc::visit_each	(	const T_action &	_A_action,
		const lambda_group3< T_functor, T_type1, T_type2, T_type3 > &	_A_target
	)			[inline]

template <class T_action, class T_functor, class T_type1, class T_type2>

void sigc::visit_each	(	const T_action &	_A_action,
		const lambda_group2< T_functor, T_type1, T_type2 > &	_A_target
	)			[inline]

template <class T_action, class T_functor, class T_type1>

void sigc::visit_each	(	const T_action &	_A_action,
		const lambda_group1< T_functor, T_type1 > &	_A_target
	)			[inline]

template <class T_action, class T_type>

void sigc::visit_each	(	const T_action &	_A_action,
		const lambda< T_type > &	_A_target
	)			[inline]

template <class T_action, class T_functor, bool I_islambda>

void sigc::visit_each	(	const T_action &	_A_action,
		const internal::lambda_core< T_functor, I_islambda > &	_A_target
	)			[inline]

template <class T_action, class T_functor, class T_catcher, class T_return>

void sigc::visit_each	(	const T_action &	_A_action,
		const exception_catch_functor< T_functor, T_catcher, T_return > &	_A_target
	)			[inline]

template <class T_action, class T_type>

void sigc::visit_each	(	const T_action &	_A_action,
		const bound_argument< T_type > &	_A_argument
	)			[inline]

Implementation of visit_each() specialized for the bound_argument class.

Call visit_each() on the entity returned by the bound_argument's visit() method. T_action The type of functor to invoke. T_type The type of bound_argument.

Parameters:

	_A_action	The functor to invoke.
	_A_argument	The visited instance.

---

Variable Documentation

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

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

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

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

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

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

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

---