logo top
Main Page   Groups   Namespaces  

sigc Namespace Reference


Classes

struct  sigc::adaptor_functor<T_functor>
 Converts an arbitrary functor into an adaptor type. More...
struct  sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::adaptor_trait<T_functor, true>
 Trait that specifies what is the adaptor version of a functor type. More...
struct  sigc::adaptor_trait<T_functor, false>
 Trait that specifies what is the adaptor version of a functor type. More...
struct  sigc::adapts<T_functor>
 Base type for adaptors. More...
struct  sigc::bind_functor<0, T_functor, T_bound, nil, nil, nil, nil, nil, nil>
 Adaptor that binds an argument to the wrapped functor. More...
struct  sigc::bind_functor<0, T_functor, T_bound, nil, nil, nil, nil, nil, nil>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::bind_functor<1, T_functor, T_bound, nil, nil, nil, nil, nil, nil>
 Adaptor that binds an argument to the wrapped functor. More...
struct  sigc::bind_functor<1, T_functor, T_bound, nil, nil, nil, nil, nil, nil>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::bind_functor<2, T_functor, T_bound, nil, nil, nil, nil, nil, nil>
 Adaptor that binds an argument to the wrapped functor. More...
struct  sigc::bind_functor<2, T_functor, T_bound, nil, nil, nil, nil, nil, nil>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::bind_functor<3, T_functor, T_bound, nil, nil, nil, nil, nil, nil>
 Adaptor that binds an argument to the wrapped functor. More...
struct  sigc::bind_functor<3, T_functor, T_bound, nil, nil, nil, nil, nil, nil>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::bind_functor<4, T_functor, T_bound, nil, nil, nil, nil, nil, nil>
 Adaptor that binds an argument to the wrapped functor. More...
struct  sigc::bind_functor<4, T_functor, T_bound, nil, nil, nil, nil, nil, nil>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::bind_functor<5, T_functor, T_bound, nil, nil, nil, nil, nil, nil>
 Adaptor that binds an argument to the wrapped functor. More...
struct  sigc::bind_functor<5, T_functor, T_bound, nil, nil, nil, nil, nil, nil>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::bind_functor<6, T_functor, T_bound, nil, nil, nil, nil, nil, nil>
 Adaptor that binds an argument to the wrapped functor. More...
struct  sigc::bind_functor<6, T_functor, T_bound, nil, nil, nil, nil, nil, nil>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::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  sigc::bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil >::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::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  sigc::bind_functor<-1, T_functor, T_type1, T_type2, nil, nil, nil, nil, nil >::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::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  sigc::bind_functor<-1, T_functor, T_type1, T_type2, T_type3, nil, nil, nil, nil >::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::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  sigc::bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, nil, nil, nil >::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::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  sigc::bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, nil, nil >::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::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  sigc::bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, nil >::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::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  sigc::bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::bind_return_functor<T_return, T_functor>
 Adaptor that fixes the return value of the wrapped functor. More...
struct  sigc::bind_return_functor<T_return, T_functor>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::compose1_functor<T_setter, T_getter>
 Adaptor that combines two functors. More...
struct  sigc::compose1_functor<T_setter, T_getter>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::compose2_functor<T_setter, T_getter1, T_getter2>
 Adaptor that combines three functors. More...
struct  sigc::compose2_functor<T_setter, T_getter1, T_getter2>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::adaptor_base
 A hint to the compiler. More...
struct  sigc::deduce_result_type<T_functor, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, I_derives_adaptor_base>
 Deduce the return type of a functor. More...
struct  sigc::deduce_result_type<T_functor, void, void, void, void, void, void, void, true>
 Deduce the return type of a functor. More...
struct  sigc::deduce_result_type<T_functor, T_arg1, void, void, void, void, void, void, true>
 Deduce the return type of a functor. More...
struct  sigc::deduce_result_type<T_functor, T_arg1, T_arg2, void, void, void, void, void, true>
 Deduce the return type of a functor. More...
struct  sigc::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  sigc::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  sigc::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  sigc::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  sigc::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  sigc::exception_catch_functor<T_functor, T_catcher, T_return>
struct  sigc::exception_catch_functor<T_functor, T_catcher, T_return>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::exception_catch_functor<T_functor, T_catcher, void>
struct  sigc::hide_functor<-1, T_functor >
 Adaptor that adds a dummy parameter to the wrapped functor. More...
struct  sigc::hide_functor<-1, T_functor >::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::hide_functor<0, T_functor>
 Adaptor that adds a dummy parameter to the wrapped functor. More...
struct  sigc::hide_functor<0, T_functor>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::hide_functor<1, T_functor>
 Adaptor that adds a dummy parameter to the wrapped functor. More...
struct  sigc::hide_functor<1, T_functor>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::hide_functor<2, T_functor>
 Adaptor that adds a dummy parameter to the wrapped functor. More...
struct  sigc::hide_functor<2, T_functor>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::hide_functor<3, T_functor>
 Adaptor that adds a dummy parameter to the wrapped functor. More...
struct  sigc::hide_functor<3, T_functor>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::hide_functor<4, T_functor>
 Adaptor that adds a dummy parameter to the wrapped functor. More...
struct  sigc::hide_functor<4, T_functor>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::hide_functor<5, T_functor>
 Adaptor that adds a dummy parameter to the wrapped functor. More...
struct  sigc::hide_functor<5, T_functor>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::hide_functor<6, T_functor>
 Adaptor that adds a dummy parameter to the wrapped functor. More...
struct  sigc::hide_functor<6, T_functor>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::lambda_base
 A hint to the compiler. More...
struct  sigc::lambda<T_type>
 Lambda type. More...
struct  sigc::unwrap_lambda_type<T_type>
 Deduces the type of the object stored in an object of the passed lambda type. More...
struct  sigc::unwrap_lambda_type<lambda<T_type>>
struct  sigc::lambda_group1<T_functor, T_type1>
struct  sigc::lambda_group1<T_functor, T_type1>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::lambda_group2<T_functor, T_type1, T_type2>
struct  sigc::lambda_group2<T_functor, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::lambda_group3<T_functor, T_type1, T_type2, T_type3>
struct  sigc::lambda_group3<T_functor, T_type1, T_type2, T_type3>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::dereference_trait<T_type>
 Deduces the base type of a reference or a pointer. More...
struct  sigc::dereference_trait<T_type*>
struct  sigc::dereference_trait<const T_type*>
struct  sigc::dereference_trait<T_type*&>
struct  sigc::dereference_trait<const T_type*&>
struct  sigc::dereference_trait<T_type* const&>
struct  sigc::dereference_trait<const T_type* const&>
struct  sigc::arithmetic<T_type>
struct  sigc::bitwise<T_type>
struct  sigc::logical<T_type>
struct  sigc::relational<T_type>
struct  sigc::arithmetic_assign<T_type>
struct  sigc::bitwise_assign<T_type>
struct  sigc::other<T_type>
struct  sigc::unary_arithmetic<T_type>
struct  sigc::unary_bitwise<T_type>
struct  sigc::unary_logical<T_type>
struct  sigc::unary_other<T_type>
struct  sigc::cast_<T_type>
struct  sigc::plus
struct  sigc::minus
struct  sigc::multiplies
struct  sigc::divides
struct  sigc::modulus
struct  sigc::leftshift
struct  sigc::rightshift
struct  sigc::and_
struct  sigc::or_
struct  sigc::xor_
struct  sigc::less
struct  sigc::greater
struct  sigc::less_equal
struct  sigc::greater_equal
struct  sigc::equal_to
struct  sigc::not_equal_to
struct  sigc::subscript
struct  sigc::assign
struct  sigc::pre_increment
struct  sigc::pre_decrement
struct  sigc::negate
struct  sigc::not_
struct  sigc::address
struct  sigc::dereference
struct  sigc::reinterpret_
struct  sigc::static_
struct  sigc::dynamic_
struct  sigc::lambda_action_deduce_result_type<T_action, T_test1, T_test2>
struct  sigc::lambda_action_deduce_result_type<logical<T_action>, T_test1, T_test2>
struct  sigc::lambda_action_deduce_result_type<relational<T_action>, T_test1, T_test2>
struct  sigc::lambda_action_deduce_result_type<arithmetic_assign<T_action>, T_test1, T_test2>
struct  sigc::lambda_action_deduce_result_type<bitwise_assign<T_action>, T_test1, T_test2>
struct  sigc::lambda_action_deduce_result_type<other<subscript>, T_test1, T_test2>
struct  sigc::lambda_action_unary_deduce_result_type<T_action, T_test>
struct  sigc::lambda_action_convert_deduce_result_type<T_action, T_type, T_test>
struct  sigc::lambda_action_unary_deduce_result_type<unary_logical<T_action>, T_test>
struct  sigc::lambda_action_unary_deduce_result_type<unary_other<address>, T_test>
struct  sigc::lambda_action_unary_deduce_result_type<unary_other<dereference>, T_test>
struct  sigc::lambda_action<T_action>
struct  sigc::lambda_action_unary<T_action>
struct  sigc::lambda_action_convert<T_action, T_type>
struct  sigc::lambda_action<arithmetic<plus>>
struct  sigc::lambda_action<arithmetic<minus>>
struct  sigc::lambda_action<arithmetic<multiplies>>
struct  sigc::lambda_action<arithmetic<divides>>
struct  sigc::lambda_action<arithmetic<modulus>>
struct  sigc::lambda_action<bitwise<leftshift>>
struct  sigc::lambda_action<bitwise<rightshift>>
struct  sigc::lambda_action<bitwise<and_>>
struct  sigc::lambda_action<bitwise<or_>>
struct  sigc::lambda_action<bitwise<xor_>>
struct  sigc::lambda_action<logical<and_>>
struct  sigc::lambda_action<logical<or_>>
struct  sigc::lambda_action<relational<less>>
struct  sigc::lambda_action<relational<greater>>
struct  sigc::lambda_action<relational<less_equal>>
struct  sigc::lambda_action<relational<greater_equal>>
struct  sigc::lambda_action<relational<equal_to>>
struct  sigc::lambda_action<relational<not_equal_to>>
struct  sigc::lambda_action<arithmetic_assign<plus>>
struct  sigc::lambda_action<arithmetic_assign<minus>>
struct  sigc::lambda_action<arithmetic_assign<multiplies>>
struct  sigc::lambda_action<arithmetic_assign<divides>>
struct  sigc::lambda_action<arithmetic_assign<modulus>>
struct  sigc::lambda_action<bitwise_assign<leftshift>>
struct  sigc::lambda_action<bitwise_assign<rightshift>>
struct  sigc::lambda_action<bitwise_assign<and_>>
struct  sigc::lambda_action<bitwise_assign<or_>>
struct  sigc::lambda_action<bitwise_assign<xor_>>
struct  sigc::lambda_action<other<subscript>>
struct  sigc::lambda_action<other<assign>>
struct  sigc::lambda_action_unary<unary_arithmetic<pre_increment>>
struct  sigc::lambda_action_unary<unary_arithmetic<pre_decrement>>
struct  sigc::lambda_action_unary<unary_arithmetic<negate>>
struct  sigc::lambda_action_unary<unary_bitwise<not_>>
struct  sigc::lambda_action_unary<unary_logical<not_>>
struct  sigc::lambda_action_unary<unary_other<address>>
struct  sigc::lambda_action_unary<unary_other<dereference>>
struct  sigc::lambda_action_convert<cast_<reinterpret_>, T_type>
struct  sigc::lambda_action_convert<cast_<static_>, T_type>
struct  sigc::lambda_action_convert<cast_<dynamic_>, T_type>
struct  sigc::lambda_operator<T_action, T_type1, T_type2>
struct  sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::lambda_operator_unary<T_action, T_type>
struct  sigc::lambda_operator_unary<T_action, T_type>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::lambda_operator_convert<T_action, T_type, T_arg>
struct  sigc::lambda_operator_convert<T_action, T_type, T_arg>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>
 Adaptor that performs C-style casts on the parameters passed on to the functor. More...
struct  sigc::retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::retype_return_functor<T_return, T_functor>
 Adaptor that perform a C-style cast on the return value of a functor. More...
struct  sigc::retype_return_functor<T_return, T_functor>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::retype_return_functor<void, T_functor>
 Adaptor that perform a C-style cast on the return value of a functor. More...
struct  sigc::retype_return_functor<void, T_functor>::deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
struct  sigc::connection
 Convinience class for safe disconnection. More...
struct  sigc::functor_base
 A hint to the compiler. More...
struct  sigc::functor_trait<T_functor, I_derives_functor_base>
struct  sigc::functor_trait<T_functor, true>
struct  sigc::functor_trait<T_return(*)(), false>
struct  sigc::functor_trait<T_return(*)(T_arg1), false>
struct  sigc::functor_trait<T_return(*)(T_arg1, T_arg2), false>
struct  sigc::functor_trait<T_return(*)(T_arg1, T_arg2, T_arg3), false>
struct  sigc::functor_trait<T_return(*)(T_arg1, T_arg2, T_arg3, T_arg4), false>
struct  sigc::functor_trait<T_return(*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5), false>
struct  sigc::functor_trait<T_return(*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6), false>
struct  sigc::functor_trait<T_return(*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7), false>
struct  sigc::functor_trait<T_return(T_obj::*)(), false>
struct  sigc::functor_trait<T_return(T_obj::*)() const, false>
struct  sigc::functor_trait<T_return(T_obj::*)(T_arg1), false>
struct  sigc::functor_trait<T_return(T_obj::*)(T_arg1) const, false>
struct  sigc::functor_trait<T_return(T_obj::*)(T_arg1, T_arg2), false>
struct  sigc::functor_trait<T_return(T_obj::*)(T_arg1, T_arg2) const, false>
struct  sigc::functor_trait<T_return(T_obj::*)(T_arg1, T_arg2, T_arg3), false>
struct  sigc::functor_trait<T_return(T_obj::*)(T_arg1, T_arg2, T_arg3) const, false>
struct  sigc::functor_trait<T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4), false>
struct  sigc::functor_trait<T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4) const, false>
struct  sigc::functor_trait<T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5), false>
struct  sigc::functor_trait<T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const, false>
struct  sigc::functor_trait<T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6), false>
struct  sigc::functor_trait<T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const, false>
struct  sigc::functor_trait<T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7), false>
struct  sigc::functor_trait<T_return(T_obj::*)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const, false>
class  sigc::mem_functor0<T_return, T_obj>
 mem_functor0 wraps methods with 0 argument(s). More...
class  sigc::mem_functor1<T_return, T_obj, T_arg1>
 mem_functor1 wraps methods with 1 argument(s). More...
class  sigc::mem_functor2<T_return, T_obj, T_arg1, T_arg2>
 mem_functor2 wraps methods with 2 argument(s). More...
class  sigc::mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
 mem_functor3 wraps methods with 3 argument(s). More...
class  sigc::mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
 mem_functor4 wraps methods with 4 argument(s). More...
class  sigc::mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
 mem_functor5 wraps methods with 5 argument(s). More...
class  sigc::mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
 mem_functor6 wraps methods with 6 argument(s). More...
class  sigc::mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
 mem_functor7 wraps methods with 7 argument(s). More...
class  sigc::const_mem_functor0<T_return, T_obj>
 const_mem_functor0 wraps const methods with 0 argument(s). More...
class  sigc::const_mem_functor1<T_return, T_obj, T_arg1>
 const_mem_functor1 wraps const methods with 1 argument(s). More...
class  sigc::const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
 const_mem_functor2 wraps const methods with 2 argument(s). More...
class  sigc::const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
 const_mem_functor3 wraps const methods with 3 argument(s). More...
class  sigc::const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
 const_mem_functor4 wraps const methods with 4 argument(s). More...
class  sigc::const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
 const_mem_functor5 wraps const methods with 5 argument(s). More...
class  sigc::const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
 const_mem_functor6 wraps const methods with 6 argument(s). More...
class  sigc::const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
 const_mem_functor7 wraps const methods with 7 argument(s). More...
class  sigc::volatile_mem_functor0<T_return, T_obj>
 volatile_mem_functor0 wraps volatile methods with 0 argument(s). More...
class  sigc::volatile_mem_functor1<T_return, T_obj, T_arg1>
 volatile_mem_functor1 wraps volatile methods with 1 argument(s). More...
class  sigc::volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
 volatile_mem_functor2 wraps volatile methods with 2 argument(s). More...
class  sigc::volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
 volatile_mem_functor3 wraps volatile methods with 3 argument(s). More...
class  sigc::volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
 volatile_mem_functor4 wraps volatile methods with 4 argument(s). More...
class  sigc::volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
 volatile_mem_functor5 wraps volatile methods with 5 argument(s). More...
class  sigc::volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
 volatile_mem_functor6 wraps volatile methods with 6 argument(s). More...
class  sigc::volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
 volatile_mem_functor7 wraps volatile methods with 7 argument(s). More...
class  sigc::const_volatile_mem_functor0<T_return, T_obj>
 const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s). More...
class  sigc::const_volatile_mem_functor1<T_return, T_obj, T_arg1>
 const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s). More...
class  sigc::const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
 const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s). More...
class  sigc::const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
 const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s). More...
class  sigc::const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
 const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s). More...
class  sigc::const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
 const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s). More...
class  sigc::const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
 const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s). More...
class  sigc::const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
 const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s). More...
class  sigc::bound_mem_functor0<T_return, T_obj>
 bound_mem_functor0 encapsulates a method with 0 arguments and an object instance. More...
class  sigc::bound_mem_functor1<T_return, T_obj, T_arg1>
 bound_mem_functor1 encapsulates a method with 1 arguments and an object instance. More...
class  sigc::bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
 bound_mem_functor2 encapsulates a method with 2 arguments and an object instance. More...
class  sigc::bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
 bound_mem_functor3 encapsulates a method with 3 arguments and an object instance. More...
class  sigc::bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
 bound_mem_functor4 encapsulates a method with 4 arguments and an object instance. More...
class  sigc::bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
 bound_mem_functor5 encapsulates a method with 5 arguments and an object instance. More...
class  sigc::bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
 bound_mem_functor6 encapsulates a method with 6 arguments and an object instance. More...
class  sigc::bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
 bound_mem_functor7 encapsulates a method with 7 arguments and an object instance. More...
class  sigc::bound_const_mem_functor0<T_return, T_obj>
 bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance. More...
class  sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1>
 bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance. More...
class  sigc::bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
 bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance. More...
class  sigc::bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
 bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance. More...
class  sigc::bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
 bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance. More...
class  sigc::bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
 bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance. More...
class  sigc::bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
 bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance. More...
class  sigc::bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
 bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance. More...
class  sigc::bound_volatile_mem_functor0<T_return, T_obj>
 bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance. More...
class  sigc::bound_volatile_mem_functor1<T_return, T_obj, T_arg1>
 bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance. More...
class  sigc::bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
 bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance. More...
class  sigc::bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
 bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance. More...
class  sigc::bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
 bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance. More...
class  sigc::bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
 bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance. More...
class  sigc::bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
 bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance. More...
class  sigc::bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
 bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance. More...
class  sigc::bound_const_volatile_mem_functor0<T_return, T_obj>
 bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object instance. More...
class  sigc::bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>
 bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object instance. More...
class  sigc::bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
 bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object instance. More...
class  sigc::bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
 bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object instance. More...
class  sigc::bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
 bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object instance. More...
class  sigc::bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
 bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object instance. More...
class  sigc::bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
 bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object instance. More...
class  sigc::bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
 bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object instance. More...
class  sigc::pointer_functor0<T_return>
 pointer_functor0 wraps existing non-member functions with 0 argument(s). More...
class  sigc::pointer_functor1<T_arg1, T_return>
 pointer_functor1 wraps existing non-member functions with 1 argument(s). More...
class  sigc::pointer_functor2<T_arg1, T_arg2, T_return>
 pointer_functor2 wraps existing non-member functions with 2 argument(s). More...
class  sigc::pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>
 pointer_functor3 wraps existing non-member functions with 3 argument(s). More...
class  sigc::pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>
 pointer_functor4 wraps existing non-member functions with 4 argument(s). More...
class  sigc::pointer_functor5<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return>
 pointer_functor5 wraps existing non-member functions with 5 argument(s). More...
class  sigc::pointer_functor6<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return>
 pointer_functor6 wraps existing non-member functions with 6 argument(s). More...
class  sigc::pointer_functor7<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return>
 pointer_functor7 wraps existing non-member functions with 7 argument(s). More...
class  sigc::slot0<T_return>
 Converts an arbitrary functor to a unified type which is opaque. More...
class  sigc::slot1<T_return, T_arg1>
 Converts an arbitrary functor to a unified type which is opaque. More...
class  sigc::slot2<T_return, T_arg1, T_arg2>
 Converts an arbitrary functor to a unified type which is opaque. More...
class  sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>
 Converts an arbitrary functor to a unified type which is opaque. More...
class  sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>
 Converts an arbitrary functor to a unified type which is opaque. More...
class  sigc::slot5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
 Converts an arbitrary functor to a unified type which is opaque. More...
class  sigc::slot6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
 Converts an arbitrary functor to a unified type which is opaque. More...
class  sigc::slot7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
 Converts an arbitrary functor to a unified type which is opaque. More...
class  sigc::slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
 Convenience wrapper for the numbered sigc::slot# templates. More...
class  sigc::slot<T_return, nil, nil, nil, nil, nil, nil, nil>
 Convenience wrapper for the numbered sigc::slot0 template. More...
class  sigc::slot<T_return, T_arg1, nil, nil, nil, nil, nil, nil>
 Convenience wrapper for the numbered sigc::slot1 template. More...
class  sigc::slot<T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil>
 Convenience wrapper for the numbered sigc::slot2 template. More...
class  sigc::slot<T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil>
 Convenience wrapper for the numbered sigc::slot3 template. More...
class  sigc::slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil>
 Convenience wrapper for the numbered sigc::slot4 template. More...
class  sigc::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  sigc::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  sigc::slot_base
 Base type for slots. More...
struct  sigc::reference_wrapper<T_type>
 Reference wrapper. More...
struct  sigc::const_reference_wrapper<T_type>
 Const reference wrapper. More...
struct  sigc::unwrap_reference<T_type>
struct  sigc::unwrap_reference<reference_wrapper<T_type>>
struct  sigc::unwrap_reference<const_reference_wrapper<T_type>>
struct  sigc::slot_iterator<T_slot>
 STL-style iterator for slot_list. More...
struct  sigc::slot_const_iterator<T_slot>
 STL-style const iterator for slot_list. More...
struct  sigc::slot_list<T_slot>
 STL-style list interface for sigc::signal#. More...
class  sigc::signal0<T_return, T_accumulator>
 Signal declaration. More...
class  sigc::signal1<T_return, T_arg1, T_accumulator>
 Signal declaration. More...
class  sigc::signal2<T_return, T_arg1, T_arg2, T_accumulator>
 Signal declaration. More...
class  sigc::signal3<T_return, T_arg1, T_arg2, T_arg3, T_accumulator>
 Signal declaration. More...
class  sigc::signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator>
 Signal declaration. More...
class  sigc::signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator>
 Signal declaration. More...
class  sigc::signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator>
 Signal declaration. More...
class  sigc::signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator>
 Signal declaration. More...
class  sigc::signal<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
 Convenience wrapper for the numbered sigc::signal# templates. More...
class  sigc::signal<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::accumulated<T_accumulator>
 Convenience wrapper for the numbered sigc::signal# templates. More...
class  sigc::signal<T_return, nil, nil, nil, nil, nil, nil, nil>
 Convenience wrapper for the numbered sigc::signal0 template. More...
class  sigc::signal<T_return, nil, nil, nil, nil, nil, nil, nil>::accumulated<T_accumulator>
 Convenience wrapper for the numbered sigc::signal0 template. More...
class  sigc::signal<T_return, T_arg1, nil, nil, nil, nil, nil, nil>
 Convenience wrapper for the numbered sigc::signal1 template. More...
class  sigc::signal<T_return, T_arg1, nil, nil, nil, nil, nil, nil>::accumulated<T_accumulator>
 Convenience wrapper for the numbered sigc::signal1 template. More...
class  sigc::signal<T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil>
 Convenience wrapper for the numbered sigc::signal2 template. More...
class  sigc::signal<T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil>::accumulated<T_accumulator>
 Convenience wrapper for the numbered sigc::signal2 template. More...
class  sigc::signal<T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil>
 Convenience wrapper for the numbered sigc::signal3 template. More...
class  sigc::signal<T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil>::accumulated<T_accumulator>
 Convenience wrapper for the numbered sigc::signal3 template. More...
class  sigc::signal<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil>
 Convenience wrapper for the numbered sigc::signal4 template. More...
class  sigc::signal<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil>::accumulated<T_accumulator>
 Convenience wrapper for the numbered sigc::signal4 template. More...
class  sigc::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  sigc::signal<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil>::accumulated<T_accumulator>
 Convenience wrapper for the numbered sigc::signal5 template. More...
class  sigc::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...
class  sigc::signal<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>::accumulated<T_accumulator>
 Convenience wrapper for the numbered sigc::signal6 template. More...
struct  sigc::signal_base
 Base class for the sigc::signal# templates. More...
struct  sigc::trackable
 Base class for objects with auto-disconnection. More...
struct  sigc::type_trait<T_type>
struct  sigc::type_trait< T_type[N]>
struct  sigc::type_trait<T_type&>
struct  sigc::type_trait<const T_type&>
struct  sigc::type_trait<reference_wrapper<T_type>>
struct  sigc::type_trait<const_reference_wrapper<T_type>>
struct  sigc::type_trait<void>
struct  sigc::is_base_and_derived<T_base, T_derived>
 From Esa Pulkkin: Compile-time determination of base-class relationship in C++ (adapted to match the syntax of boost's type_traits library). More...
struct  sigc::is_base_and_derived< T_base, T_derived >::big
struct  sigc::is_base_and_derived<T_base, T_base>

Functions

template<class T_action, class T_functor>
void visit_each (const T_action& _A_action, const adaptor_functor<T_functor>& _A_target)
 Performs a functor on each of the targets of a functor.
template<class T_action, int T_loc, class T_functor, class T_bound>
void visit_each (const T_action& _A_action, const bind_functor<T_loc, T_functor, T_bound>& _A_target)
 Performs a functor on each of the targets of a functor.
template<class T_action, class T_functor, class T_type1>
void visit_each (const T_action& _A_action, const bind_functor<-1, T_functor, T_type1 >& _A_target)
 Performs a functor on each of the targets of a functor.
template<class T_action, class T_functor, class T_type1, class T_type2>
void visit_each (const T_action& _A_action, const bind_functor<-1, T_functor, T_type1, T_type2 >& _A_target)
 Performs a functor on each of the targets of a functor.
template<class T_action, class T_functor, class T_type1, class T_type2, class T_type3>
void visit_each (const T_action& _A_action, const bind_functor<-1, T_functor, T_type1, T_type2, T_type3 >& _A_target)
 Performs a functor on each of the targets of a functor.
template<class T_action, class T_functor, class T_type1, class T_type2, class T_type3, class T_type4>
void visit_each (const T_action& _A_action, const bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4 >& _A_target)
 Performs a functor on each of the targets of a functor.
template<class T_action, class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5>
void visit_each (const T_action& _A_action, const bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5 >& _A_target)
 Performs a functor on each of the targets of a functor.
template<class T_action, class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6>
void visit_each (const T_action& _A_action, const bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6 >& _A_target)
 Performs a functor on each of the targets of a functor.
template<class T_action, class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6, class T_type7>
void visit_each (const T_action& _A_action, const bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7 >& _A_target)
 Performs a functor on each of the targets of a functor.
template<int I_location, class T_bound1, class T_functor>
bind_functor< I_location,
T_functor, typename unwrap_reference<
T_bound1 >::type > 
bind (const T_functor& _A_func, T_bound1 _A_b1)
 Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.
template<class T_type1, class T_functor>
bind_functor<-1, T_functor,
typename unwrap_reference<
T_type1 >::type > 
bind (const T_functor& _A_func, T_type1 _A_b1)
 Creates an adaptor of type sigc::bind_functor which fixes the last 1 argument(s) of the passed functor.
template<class T_type1, class T_type2, class T_functor>
bind_functor<-1, T_functor,
typename unwrap_reference<
T_type1 >::type, typename
unwrap_reference< T_type2
>::type > 
bind (const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2)
 Creates an adaptor of type sigc::bind_functor which fixes the last 2 argument(s) of the passed functor.
template<class T_type1, class T_type2, class T_type3, class T_functor>
bind_functor<-1, T_functor,
typename unwrap_reference<
T_type1 >::type, typename
unwrap_reference< T_type2
>::type, typename unwrap_reference<
T_type3 >::type > 
bind (const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3)
 Creates an adaptor of type sigc::bind_functor which fixes the last 3 argument(s) of the passed functor.
template<class T_type1, class T_type2, class T_type3, class T_type4, class T_functor>
bind_functor<-1, T_functor,
typename unwrap_reference<
T_type1 >::type, typename
unwrap_reference< T_type2
>::type, typename unwrap_reference<
T_type3 >::type, typename
unwrap_reference< T_type4
>::type > 
bind (const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4)
 Creates an adaptor of type sigc::bind_functor which fixes the last 4 argument(s) of the passed functor.
template<class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_functor>
bind_functor<-1, T_functor,
typename unwrap_reference<
T_type1 >::type, typename
unwrap_reference< T_type2
>::type, typename unwrap_reference<
T_type3 >::type, typename
unwrap_reference< T_type4
>::type, typename unwrap_reference<
T_type5 >::type > 
bind (const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5)
 Creates an adaptor of type sigc::bind_functor which fixes the last 5 argument(s) of the passed functor.
template<class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6, class T_functor>
bind_functor<-1, T_functor,
typename unwrap_reference<
T_type1 >::type, typename
unwrap_reference< T_type2
>::type, typename unwrap_reference<
T_type3 >::type, typename
unwrap_reference< T_type4
>::type, typename unwrap_reference<
T_type5 >::type, typename
unwrap_reference< T_type6
>::type > 
bind (const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5, T_type6 _A_b6)
 Creates an adaptor of type sigc::bind_functor which fixes the last 6 argument(s) of the passed functor.
template<class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6, class T_type7, class T_functor>
bind_functor<-1, T_functor,
typename unwrap_reference<
T_type1 >::type, typename
unwrap_reference< T_type2
>::type, typename unwrap_reference<
T_type3 >::type, typename
unwrap_reference< T_type4
>::type, typename unwrap_reference<
T_type5 >::type, typename
unwrap_reference< T_type6
>::type, typename unwrap_reference<
T_type7 >::type > 
bind (const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5, T_type6 _A_b6, T_type7 _A_b7)
 Creates an adaptor of type sigc::bind_functor which fixes the last 7 argument(s) of the passed functor.
template<class T_action, class T_return, class T_functor>
void visit_each (const T_action& _A_action, const bind_return_functor<T_return, T_functor>& _A_target)
 Performs a functor on each of the targets of a functor.
template<class T_return, class T_functor>
bind_return_functor< typename
unwrap_reference< T_return
>::type, T_functor > 
bind_return (const T_functor& _A_functor, T_return _A_ret_value)
 Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed functor to the passed argument.
template<class T_action, class T_setter, class T_getter>
void visit_each (const T_action& _A_action, const compose1_functor<T_setter, T_getter>& _A_target)
 Performs a functor on each of the targets of a functor.
template<class T_action, class T_setter, class T_getter1, class T_getter2>
void visit_each (const T_action& _A_action, const compose2_functor<T_setter, T_getter1, T_getter2>& _A_target)
 Performs a functor on each of the targets of a functor.
template<class T_setter, class T_getter>
compose1_functor< T_setter,
T_getter > 
compose (const T_setter& _A_setter, const T_getter& _A_getter)
 Creates an adaptor of type sigc::compose1_functor which combines two functors.
template<class T_setter, class T_getter1, class T_getter2>
compose2_functor< T_setter,
T_getter1, T_getter2 > 
compose (const T_setter& _A_setter, const T_getter1& _A_getter1, const T_getter2& _A_getter2)
 Creates an adaptor of type sigc::compose2_functor which combines three functors.
template<class T_action, class T_functor, class T_catcher, class T_return>
void visit_each (const T_action& _A_action, const exception_catch_functor<T_functor, T_catcher, T_return>& _A_target)
template<class T_functor, class T_catcher>
exception_catch_functor< T_functor,
T_catcher > 
exception_catch (const T_functor& _A_func, const T_catcher& _A_catcher)
template<class T_action, int I_location, class T_functor>
void visit_each (const T_action& _A_action, const hide_functor<I_location, T_functor>& _A_target)
 Performs a functor on each of the targets of a functor.
template<int I_location, class T_functor>
hide_functor< I_location,
T_functor > 
hide (const T_functor& _A_func)
 Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor.
template<class T_action, class T_functor, bool I_islambda>
void visit_each (const T_action& _A_action, const internal::lambda_core<T_functor, I_islambda>& _A_target)
template<class T_action, class T_type>
void visit_each (const T_action& _A_action, const lambda<T_type>& _A_target)
template<class T_type>
lambda<T_type&> 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::const_volatile_mem_functor0 which wraps a const volatile 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::const_volatile_mem_functor1 which wraps a const volatile 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::const_volatile_mem_functor2 which wraps a const volatile method.
template<class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
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::const_volatile_mem_functor3 which wraps a const volatile method.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
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::const_volatile_mem_functor4 which wraps a const volatile method.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
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::const_volatile_mem_functor5 which wraps a const volatile method.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
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::const_volatile_mem_functor6 which wraps a const volatile method.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
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::const_volatile_mem_functor7 which wraps a const volatile method.
template<class T_return, class T_obj, class T_obj2>
bound_mem_functor0< T_return,
T_obj > 
mem_fun0 (T_obj& _A_obj, T_return(T_obj2::* _A_func)())
 Creates a functor of type sigc::bound_const_volatile_mem_functor0 which encapsulates a method and an object instance.
template<class T_arg1, class T_return, class T_obj, class T_obj2>
bound_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_const_volatile_mem_functor1 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
bound_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_const_volatile_mem_functor2 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
bound_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_const_volatile_mem_functor3 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
bound_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_const_volatile_mem_functor4 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
bound_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_const_volatile_mem_functor5 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
bound_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_const_volatile_mem_functor6 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
bound_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_const_volatile_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_volatile_mem_functor0 which encapsulates a method and an object instance.
template<class T_arg1, class T_return, class T_obj, class T_obj2>
bound_const_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_volatile_mem_functor1 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
bound_const_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_volatile_mem_functor2 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
bound_const_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_volatile_mem_functor3 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
bound_const_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_volatile_mem_functor4 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
bound_const_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_volatile_mem_functor5 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
bound_const_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_volatile_mem_functor6 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
bound_const_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_volatile_mem_functor7 which encapsulates a method and an object instance.
template<class T_return, class T_obj>
mem_functor0<T_return, T_obj> mem_fun (T_return(T_obj::* _A_func)())
 Creates a functor of type sigc::const_volatile_mem_functor0 which wraps a const volatile 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::const_volatile_mem_functor1 which wraps a const volatile 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::const_volatile_mem_functor2 which wraps a const volatile method.
template<class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
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::const_volatile_mem_functor3 which wraps a const volatile method.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
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::const_volatile_mem_functor4 which wraps a const volatile method.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
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::const_volatile_mem_functor5 which wraps a const volatile method.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
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::const_volatile_mem_functor6 which wraps a const volatile method.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
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::const_volatile_mem_functor7 which wraps a const volatile method.
template<class T_return, class T_obj, class T_obj2>
bound_mem_functor0< T_return,
T_obj > 
mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)())
 Creates a functor of type sigc::bound_const_volatile_mem_functor0 which encapsulates a method and an object instance.
template<class T_arg1, class T_return, class T_obj, class T_obj2>
bound_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_const_volatile_mem_functor1 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
bound_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_const_volatile_mem_functor2 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
bound_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_const_volatile_mem_functor3 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
bound_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_const_volatile_mem_functor4 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
bound_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_const_volatile_mem_functor5 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
bound_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_const_volatile_mem_functor6 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
bound_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_const_volatile_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_volatile_mem_functor0 which encapsulates a method and an object instance.
template<class T_arg1, class T_return, class T_obj, class T_obj2>
bound_const_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_volatile_mem_functor1 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
bound_const_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_volatile_mem_functor2 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
bound_const_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_volatile_mem_functor3 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
bound_const_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_volatile_mem_functor4 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
bound_const_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_volatile_mem_functor5 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
bound_const_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_volatile_mem_functor6 which encapsulates a method and an object instance.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
bound_const_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_volatile_mem_functor7 which encapsulates a method and an object instance.
template<class T_return>
pointer_functor0<T_return> ptr_fun0 (T_return(* _A_func)())
 Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.
template<class T_arg1, class T_return>
pointer_functor1< T_arg1,
T_return > 
ptr_fun1 (T_return(* _A_func)(T_arg1))
 Creates a functor of type sigc::pointer_functor1 which wraps an existing non-member function.
template<class T_arg1, class T_arg2, class T_return>
pointer_functor2< T_arg1,
T_arg2, T_return > 
ptr_fun2 (T_return(* _A_func)(T_arg1, T_arg2))
 Creates a functor of type sigc::pointer_functor2 which wraps an existing non-member function.
template<class T_arg1, class T_arg2, class T_arg3, class T_return>
pointer_functor3< T_arg1,
T_arg2, T_arg3, T_return > 
ptr_fun3 (T_return(* _A_func)(T_arg1, T_arg2, T_arg3))
 Creates a functor of type sigc::pointer_functor3 which wraps an existing non-member function.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return>
pointer_functor4< T_arg1,
T_arg2, T_arg3, T_arg4, T_return > 
ptr_fun4 (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))
 Creates a functor of type sigc::pointer_functor4 which wraps an existing non-member function.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return>
pointer_functor5< T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_return > 
ptr_fun5 (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))
 Creates a functor of type sigc::pointer_functor5 which wraps an existing non-member function.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return>
pointer_functor6< T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_return > 
ptr_fun6 (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))
 Creates a functor of type sigc::pointer_functor6 which wraps an existing non-member function.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return>
pointer_functor7< T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7, T_return > 
ptr_fun7 (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))
 Creates a functor of type sigc::pointer_functor7 which wraps an existing non-member function.
template<class T_return>
pointer_functor0<T_return> ptr_fun (T_return(* _A_func)())
 Creates a functor of type sigc::pointer_functor0 which wraps an existing non-member function.
template<class T_arg1, class T_return>
pointer_functor1< T_arg1,
T_return > 
ptr_fun (T_return(* _A_func)(T_arg1))
 Creates a functor of type sigc::pointer_functor1 which wraps an existing non-member function.
template<class T_arg1, class T_arg2, class T_return>
pointer_functor2< T_arg1,
T_arg2, T_return > 
ptr_fun (T_return(* _A_func)(T_arg1, T_arg2))
 Creates a functor of type sigc::pointer_functor2 which wraps an existing non-member function.
template<class T_arg1, class T_arg2, class T_arg3, class T_return>
pointer_functor3< T_arg1,
T_arg2, T_arg3, T_return > 
ptr_fun (T_return(* _A_func)(T_arg1, T_arg2, T_arg3))
 Creates a functor of type sigc::pointer_functor3 which wraps an existing non-member function.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return>
pointer_functor4< T_arg1,
T_arg2, T_arg3, T_arg4, T_return > 
ptr_fun (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))
 Creates a functor of type sigc::pointer_functor4 which wraps an existing non-member function.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return>
pointer_functor5< T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_return > 
ptr_fun (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))
 Creates a functor of type sigc::pointer_functor5 which wraps an existing non-member function.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return>
pointer_functor6< T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_return > 
ptr_fun (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))
 Creates a functor of type sigc::pointer_functor6 which wraps an existing non-member function.
template<class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return>
pointer_functor7< T_arg1,
T_arg2, T_arg3, T_arg4, T_arg5,
T_arg6, T_arg7, T_return > 
ptr_fun (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))
 Creates a functor of type sigc::pointer_functor7 which wraps an existing non-member function.
template<class T_type>
reference_wrapper<T_type> ref (T_type& v)
 Creates a reference wrapper.
template<class T_type>
const_reference_wrapper<T_type> ref (const T_type& v)
 Creates a const reference wrapper.
template<class T_type>
T_type& unwrap (T_type& v)
template<class T_type>
const T_type& unwrap (const T_type& v)
template<class T_type>
T_type& unwrap (const reference_wrapper<T_type>& v)
template<class T_type>
const T_type& unwrap (const const_reference_wrapper<T_type>& v)
template<class T_action, class T_functor>
void visit_each (const T_action& _A_action, const T_functor& _A_functor)
 This function performs a functor on each of the targets of a functor.
template<class T_type, class T_action, class T_functor>
void visit_each_type (const T_action& _A_action, const T_functor& _A_functor)
 This function performs a functor on each of the targets of a functor limited to a restricted type.

Variables

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> > dynamic_cast_ ( const T_arg&  a  ) 
 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Creates a const reference wrapper.

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

Parameters:
v Reference to store.
Returns:
A reference wrapper.

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

Creates a reference wrapper.

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

Parameters:
v Reference to store.
Returns:
A reference wrapper.

template <class T_type, class T_arg>
lambda<lambda_operator_convert<cast_<reinterpret_>, T_type, 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>
const T_type& unwrap ( const const_reference_wrapper<T_type>&  v  ) 
 

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

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

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

template <class T_type>
const T_type& unwrap_lambda_value ( const lambda<T_type>&  a  ) 
 

template <class T_type>
const T_type& unwrap_lambda_value ( const T_type&  a  ) 
 

template <class T_type>
T_type& unwrap_lambda_value ( T_type&  a  ) 
 

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&> var ( const T_type&  v  ) 
 

Converts a constant reference into a lambda object.

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

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_lambda_action, class T_type, class T_arg>
void visit_each ( const T_action&  _A_action,
const lambda_operator_convert<T_lambda_action, T_type, T_arg>&  _A_target
 

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

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

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

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

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

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

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

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


Variable Documentation

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
 


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