7072 lines
323 KiB
C++
7072 lines
323 KiB
C++
// -*- c++ -*-
|
|
/* Do not edit! -- generated file */
|
|
|
|
|
|
// implementation notes:
|
|
// - we do not use bind here, because it would introduce
|
|
// an extra copy and complicate the header include order if bind is
|
|
// to have automatic conversion for member pointers.
|
|
#ifndef _SIGC_FUNCTORS_MEM_FUN_H_
|
|
#define _SIGC_FUNCTORS_MEM_FUN_H_
|
|
#include <sigc++/type_traits.h>
|
|
#include <sigc++/functors/functor_trait.h>
|
|
#include <sigc++/limit_reference.h>
|
|
|
|
namespace sigc {
|
|
|
|
/** @defgroup mem_fun mem_fun()
|
|
* mem_fun() Creates a functor from a pointer to a method.
|
|
*
|
|
* Optionally, a reference or pointer to an object can be bound to the functor.
|
|
*
|
|
* @note If the object type inherits from sigc::trackable, and the
|
|
* functor returned from mem_fun() is assigned to a sigc::slot, the functor
|
|
* will be automatically cleared when the object goes out of scope. Invoking
|
|
* that slot will then have no effect and will not try to use the destroyed
|
|
* instance.
|
|
*
|
|
* If the member function pointer is to an overloaded type, you must specify
|
|
* the types using template arguments starting with the first argument.
|
|
* It is not necessary to supply the return type.
|
|
*
|
|
* @par Example:
|
|
* @code
|
|
* struct foo : public sigc::trackable
|
|
* {
|
|
* void bar(int) {}
|
|
* };
|
|
* foo my_foo;
|
|
* sigc::slot<void, int> sl = sigc::mem_fun(my_foo, &foo::bar);
|
|
* // Note: f is not a slot. It will not be invalidated when my_foo is deleted.
|
|
* auto f = sigc::mem_fun(my_foo, &foo::bar); // Usually not what you want.
|
|
* @endcode
|
|
*
|
|
* For const methods mem_fun() takes a const reference or pointer to an object.
|
|
*
|
|
* @par Example:
|
|
* @code
|
|
* struct foo : public sigc::trackable
|
|
* {
|
|
* void bar(int) const {}
|
|
* };
|
|
* const foo my_foo;
|
|
* sigc::slot<void, int> sl = sigc::mem_fun(my_foo, &foo::bar);
|
|
* @endcode
|
|
*
|
|
* Use mem_fun#() if there is an ambiguity as to the number of arguments.
|
|
*
|
|
* @par Example:
|
|
* @code
|
|
* struct foo : public sigc::trackable
|
|
* {
|
|
* void bar(int) {}
|
|
* void bar(float) {}
|
|
* void bar(int, int) {}
|
|
* };
|
|
* foo my_foo;
|
|
* sigc::slot<void, int> sl = sigc::mem_fun1<int>(my_foo, &foo::bar);
|
|
* @endcode
|
|
*
|
|
* @ingroup sigcfunctors
|
|
*/
|
|
|
|
/** mem_functor0 wraps methods with 0 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of mem_functor0.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
class mem_functor0 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)() ;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
mem_functor0() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a mem_functor0 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit mem_functor0(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj* _A_obj) const
|
|
{ return (_A_obj->*(this->func_ptr_))(); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj& _A_obj) const
|
|
{ return (_A_obj.*func_ptr_)(); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** mem_functor1 wraps methods with 1 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of mem_functor1.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1>
|
|
class mem_functor1 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1) ;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
mem_functor1() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a mem_functor1 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit mem_functor1(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** mem_functor2 wraps methods with 2 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of mem_functor2.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2>
|
|
class mem_functor2 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2) ;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
mem_functor2() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a mem_functor2 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit mem_functor2(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** mem_functor3 wraps methods with 3 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of mem_functor3.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
|
|
class mem_functor3 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3) ;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
mem_functor3() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a mem_functor3 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit mem_functor3(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** mem_functor4 wraps methods with 4 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of mem_functor4.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
|
|
class mem_functor4 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4) ;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
mem_functor4() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a mem_functor4 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit mem_functor4(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** mem_functor5 wraps methods with 5 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of mem_functor5.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
|
|
class mem_functor5 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) ;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
mem_functor5() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a mem_functor5 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit mem_functor5(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** mem_functor6 wraps methods with 6 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of mem_functor6.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_arg6 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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 mem_functor6 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) ;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
mem_functor6() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a mem_functor6 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit mem_functor6(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** mem_functor7 wraps methods with 7 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of mem_functor7.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_arg6 Argument type used in the definition of operator()().
|
|
* - @e T_arg7 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
class mem_functor7 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) ;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
mem_functor7() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a mem_functor7 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit mem_functor7(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @param _A_a7 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @param _A_a7 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** const_mem_functor0 wraps const methods with 0 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of const_mem_functor0.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
class const_mem_functor0 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)() const;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
const_mem_functor0() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a const_mem_functor0 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit const_mem_functor0(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj* _A_obj) const
|
|
{ return (_A_obj->*(this->func_ptr_))(); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj& _A_obj) const
|
|
{ return (_A_obj.*func_ptr_)(); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** const_mem_functor1 wraps const methods with 1 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of const_mem_functor1.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1>
|
|
class const_mem_functor1 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1) const;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
const_mem_functor1() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a const_mem_functor1 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit const_mem_functor1(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** const_mem_functor2 wraps const methods with 2 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of const_mem_functor2.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2>
|
|
class const_mem_functor2 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2) const;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
const_mem_functor2() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a const_mem_functor2 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit const_mem_functor2(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** const_mem_functor3 wraps const methods with 3 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of const_mem_functor3.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
|
|
class const_mem_functor3 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3) const;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
const_mem_functor3() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a const_mem_functor3 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit const_mem_functor3(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** const_mem_functor4 wraps const methods with 4 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of const_mem_functor4.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
|
|
class const_mem_functor4 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4) const;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
const_mem_functor4() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a const_mem_functor4 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit const_mem_functor4(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** const_mem_functor5 wraps const methods with 5 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of const_mem_functor5.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
|
|
class const_mem_functor5 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
const_mem_functor5() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a const_mem_functor5 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit const_mem_functor5(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** const_mem_functor6 wraps const methods with 6 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of const_mem_functor6.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_arg6 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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 const_mem_functor6 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
const_mem_functor6() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a const_mem_functor6 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit const_mem_functor6(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** const_mem_functor7 wraps const methods with 7 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of const_mem_functor7.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_arg6 Argument type used in the definition of operator()().
|
|
* - @e T_arg7 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
class const_mem_functor7 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
const_mem_functor7() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a const_mem_functor7 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit const_mem_functor7(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @param _A_a7 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @param _A_a7 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** volatile_mem_functor0 wraps volatile methods with 0 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of volatile_mem_functor0.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
class volatile_mem_functor0 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)() volatile;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
volatile_mem_functor0() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a volatile_mem_functor0 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit volatile_mem_functor0(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj* _A_obj) const
|
|
{ return (_A_obj->*(this->func_ptr_))(); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj& _A_obj) const
|
|
{ return (_A_obj.*func_ptr_)(); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** volatile_mem_functor1 wraps volatile methods with 1 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of volatile_mem_functor1.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1>
|
|
class volatile_mem_functor1 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1) volatile;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
volatile_mem_functor1() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a volatile_mem_functor1 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit volatile_mem_functor1(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** volatile_mem_functor2 wraps volatile methods with 2 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of volatile_mem_functor2.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2>
|
|
class volatile_mem_functor2 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2) volatile;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
volatile_mem_functor2() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a volatile_mem_functor2 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit volatile_mem_functor2(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** volatile_mem_functor3 wraps volatile methods with 3 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of volatile_mem_functor3.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
|
|
class volatile_mem_functor3 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3) volatile;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
volatile_mem_functor3() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a volatile_mem_functor3 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit volatile_mem_functor3(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** volatile_mem_functor4 wraps volatile methods with 4 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of volatile_mem_functor4.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
|
|
class volatile_mem_functor4 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4) volatile;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
volatile_mem_functor4() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a volatile_mem_functor4 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit volatile_mem_functor4(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** volatile_mem_functor5 wraps volatile methods with 5 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of volatile_mem_functor5.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
|
|
class volatile_mem_functor5 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
volatile_mem_functor5() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a volatile_mem_functor5 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit volatile_mem_functor5(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** volatile_mem_functor6 wraps volatile methods with 6 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of volatile_mem_functor6.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_arg6 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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 volatile_mem_functor6 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
volatile_mem_functor6() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a volatile_mem_functor6 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit volatile_mem_functor6(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** volatile_mem_functor7 wraps volatile methods with 7 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of volatile_mem_functor7.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_arg6 Argument type used in the definition of operator()().
|
|
* - @e T_arg7 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
class volatile_mem_functor7 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
volatile_mem_functor7() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a volatile_mem_functor7 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit volatile_mem_functor7(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @param _A_a7 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @param _A_a7 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor0.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
class const_volatile_mem_functor0 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)() const volatile;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
const_volatile_mem_functor0() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a const_volatile_mem_functor0 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit const_volatile_mem_functor0(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj* _A_obj) const
|
|
{ return (_A_obj->*(this->func_ptr_))(); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj& _A_obj) const
|
|
{ return (_A_obj.*func_ptr_)(); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor1.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1>
|
|
class const_volatile_mem_functor1 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1) const volatile;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
const_volatile_mem_functor1() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a const_volatile_mem_functor1 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit const_volatile_mem_functor1(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor2.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2>
|
|
class const_volatile_mem_functor2 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2) const volatile;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
const_volatile_mem_functor2() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a const_volatile_mem_functor2 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit const_volatile_mem_functor2(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor3.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
|
|
class const_volatile_mem_functor3 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3) const volatile;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
const_volatile_mem_functor3() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a const_volatile_mem_functor3 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit const_volatile_mem_functor3(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor4.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
|
|
class const_volatile_mem_functor4 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
const_volatile_mem_functor4() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a const_volatile_mem_functor4 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit const_volatile_mem_functor4(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor5.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
|
|
class const_volatile_mem_functor5 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
const_volatile_mem_functor5() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a const_volatile_mem_functor5 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit const_volatile_mem_functor5(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor6.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_arg6 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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 const_volatile_mem_functor6 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
const_volatile_mem_functor6() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a const_volatile_mem_functor6 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit const_volatile_mem_functor6(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
/** const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s).
|
|
* Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor7.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_arg6 Argument type used in the definition of operator()().
|
|
* - @e T_arg7 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
class const_volatile_mem_functor7 : public functor_base
|
|
{
|
|
public:
|
|
typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile;
|
|
typedef T_return result_type;
|
|
|
|
/// Constructs an invalid functor.
|
|
const_volatile_mem_functor7() : func_ptr_(nullptr) {}
|
|
|
|
/** Constructs a const_volatile_mem_functor7 object that wraps the passed method.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
explicit const_volatile_mem_functor7(function_type _A_func) : func_ptr_(_A_func) {}
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @param _A_a7 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
|
|
{ return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Execute the wrapped method operating on the passed instance.
|
|
* @param _A_obj Reference to instance the method should operate on.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @param _A_a7 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
|
|
{ return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
|
|
|
|
protected:
|
|
function_type func_ptr_;
|
|
};
|
|
|
|
|
|
/** bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_mem_functor0.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
class bound_mem_functor0
|
|
: public mem_functor0<T_return, T_obj>
|
|
{
|
|
typedef mem_functor0<T_return, T_obj> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_mem_functor0 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_mem_functor0( T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_mem_functor0 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_mem_functor0( T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()() const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
struct visitor<bound_mem_functor0<T_return, T_obj> >
|
|
{
|
|
template <class T_action>
|
|
static void do_visit_each(const T_action& _A_action,
|
|
const bound_mem_functor0<T_return, T_obj>& _A_target)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_mem_functor1.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1>
|
|
class bound_mem_functor1
|
|
: public mem_functor1<T_return, T_obj, T_arg1>
|
|
{
|
|
typedef mem_functor1<T_return, T_obj, T_arg1> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_mem_functor1 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_mem_functor1( T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_mem_functor1 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_mem_functor1( T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1>
|
|
struct visitor<bound_mem_functor1<T_return, T_obj, T_arg1> >
|
|
{
|
|
template <class T_action>
|
|
static void do_visit_each(const T_action& _A_action,
|
|
const bound_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_mem_functor2.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2>
|
|
class bound_mem_functor2
|
|
: public mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
{
|
|
typedef mem_functor2<T_return, T_obj, T_arg1, T_arg2> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_mem_functor2 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_mem_functor2( T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_mem_functor2 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_mem_functor2( T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2>
|
|
struct visitor<bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2> >
|
|
{
|
|
template <class T_action>
|
|
static void do_visit_each(const T_action& _A_action,
|
|
const bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_target)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_mem_functor3.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
|
|
class bound_mem_functor3
|
|
: public mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
{
|
|
typedef mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_mem_functor3 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_mem_functor3( T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_mem_functor3 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_mem_functor3( T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
|
|
struct visitor<bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> >
|
|
{
|
|
template <class T_action>
|
|
static void do_visit_each(const T_action& _A_action,
|
|
const bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_target)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_mem_functor4.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
|
|
class bound_mem_functor4
|
|
: public mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
{
|
|
typedef mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_mem_functor4 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_mem_functor4( T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_mem_functor4 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_mem_functor4( T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
|
|
struct visitor<bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> >
|
|
{
|
|
template <class T_action>
|
|
static void do_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)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_mem_functor5.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
|
|
class bound_mem_functor5
|
|
: public mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
{
|
|
typedef mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_mem_functor5 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_mem_functor5( T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_mem_functor5 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_mem_functor5( T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
|
|
struct visitor<bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> >
|
|
{
|
|
template <class T_action>
|
|
static void do_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)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_mem_functor6.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_arg6 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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 bound_mem_functor6
|
|
: public mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
{
|
|
typedef mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_mem_functor6 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_mem_functor6( T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_mem_functor6 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_mem_functor6( T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
struct visitor<bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> >
|
|
{
|
|
template <class T_action>
|
|
static void do_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)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_mem_functor7.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_arg6 Argument type used in the definition of operator()().
|
|
* - @e T_arg7 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
class bound_mem_functor7
|
|
: public mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
{
|
|
typedef mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_mem_functor7 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_mem_functor7( T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_mem_functor7 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_mem_functor7( T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @param _A_a7 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
struct visitor<bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> >
|
|
{
|
|
template <class T_action>
|
|
static void do_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)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_const_mem_functor0.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
class bound_const_mem_functor0
|
|
: public const_mem_functor0<T_return, T_obj>
|
|
{
|
|
typedef const_mem_functor0<T_return, T_obj> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_const_mem_functor0 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_mem_functor0(const T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_const_mem_functor0 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_mem_functor0(const T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()() const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
const_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_const_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_const_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
struct visitor<bound_const_mem_functor0<T_return, T_obj> >
|
|
{
|
|
template <class T_action>
|
|
static void do_visit_each(const T_action& _A_action,
|
|
const bound_const_mem_functor0<T_return, T_obj>& _A_target)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_const_mem_functor1.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1>
|
|
class bound_const_mem_functor1
|
|
: public const_mem_functor1<T_return, T_obj, T_arg1>
|
|
{
|
|
typedef const_mem_functor1<T_return, T_obj, T_arg1> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_const_mem_functor1 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_mem_functor1(const T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_const_mem_functor1 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_mem_functor1(const T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
const_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_const_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_const_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1>
|
|
struct visitor<bound_const_mem_functor1<T_return, T_obj, T_arg1> >
|
|
{
|
|
template <class T_action>
|
|
static void do_visit_each(const T_action& _A_action,
|
|
const bound_const_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_const_mem_functor2.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2>
|
|
class bound_const_mem_functor2
|
|
: public const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
{
|
|
typedef const_mem_functor2<T_return, T_obj, T_arg1, T_arg2> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_const_mem_functor2 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_mem_functor2(const T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_const_mem_functor2 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_mem_functor2(const T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
const_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_const_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_const_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2>
|
|
struct visitor<bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2> >
|
|
{
|
|
template <class T_action>
|
|
static void do_visit_each(const T_action& _A_action,
|
|
const bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_target)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_const_mem_functor3.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
|
|
class bound_const_mem_functor3
|
|
: public const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
{
|
|
typedef const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_const_mem_functor3 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_mem_functor3(const T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_const_mem_functor3 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_mem_functor3(const T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
const_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_const_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_const_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
|
|
struct visitor<bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> >
|
|
{
|
|
template <class T_action>
|
|
static void do_visit_each(const T_action& _A_action,
|
|
const bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_target)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_const_mem_functor4.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
|
|
class bound_const_mem_functor4
|
|
: public const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
{
|
|
typedef const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_const_mem_functor4 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_mem_functor4(const T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_const_mem_functor4 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_mem_functor4(const T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
const_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_const_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_const_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
|
|
struct visitor<bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> >
|
|
{
|
|
template <class T_action>
|
|
static void do_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)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_const_mem_functor5.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
|
|
class bound_const_mem_functor5
|
|
: public const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
{
|
|
typedef const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_const_mem_functor5 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_mem_functor5(const T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_const_mem_functor5 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_mem_functor5(const T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
const_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_const_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_const_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
|
|
struct visitor<bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> >
|
|
{
|
|
template <class T_action>
|
|
static void do_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)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_const_mem_functor6.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_arg6 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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 bound_const_mem_functor6
|
|
: public const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
{
|
|
typedef const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_const_mem_functor6 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_mem_functor6(const T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_const_mem_functor6 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_mem_functor6(const T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
const_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_const_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_const_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
struct visitor<bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> >
|
|
{
|
|
template <class T_action>
|
|
static void do_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)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_const_mem_functor7.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_arg6 Argument type used in the definition of operator()().
|
|
* - @e T_arg7 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
class bound_const_mem_functor7
|
|
: public const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
{
|
|
typedef const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_const_mem_functor7 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_mem_functor7(const T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_const_mem_functor7 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_mem_functor7(const T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @param _A_a7 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
const_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_const_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_const_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
struct visitor<bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> >
|
|
{
|
|
template <class T_action>
|
|
static void do_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)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor0.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
class bound_volatile_mem_functor0
|
|
: public volatile_mem_functor0<T_return, T_obj>
|
|
{
|
|
typedef volatile_mem_functor0<T_return, T_obj> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_volatile_mem_functor0 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_volatile_mem_functor0( T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_volatile_mem_functor0 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_volatile_mem_functor0( T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()() const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
volatile_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_volatile_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_volatile_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
struct visitor<bound_volatile_mem_functor0<T_return, T_obj> >
|
|
{
|
|
template <class T_action>
|
|
static void do_visit_each(const T_action& _A_action,
|
|
const bound_volatile_mem_functor0<T_return, T_obj>& _A_target)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor1.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1>
|
|
class bound_volatile_mem_functor1
|
|
: public volatile_mem_functor1<T_return, T_obj, T_arg1>
|
|
{
|
|
typedef volatile_mem_functor1<T_return, T_obj, T_arg1> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_volatile_mem_functor1 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_volatile_mem_functor1( T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_volatile_mem_functor1 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_volatile_mem_functor1( T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
volatile_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_volatile_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_volatile_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1>
|
|
struct visitor<bound_volatile_mem_functor1<T_return, T_obj, T_arg1> >
|
|
{
|
|
template <class T_action>
|
|
static void do_visit_each(const T_action& _A_action,
|
|
const bound_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor2.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2>
|
|
class bound_volatile_mem_functor2
|
|
: public volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
{
|
|
typedef volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_volatile_mem_functor2 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_volatile_mem_functor2( T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_volatile_mem_functor2 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_volatile_mem_functor2( T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
volatile_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_volatile_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_volatile_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2>
|
|
struct visitor<bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2> >
|
|
{
|
|
template <class T_action>
|
|
static void do_visit_each(const T_action& _A_action,
|
|
const bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_target)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor3.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
|
|
class bound_volatile_mem_functor3
|
|
: public volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
{
|
|
typedef volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_volatile_mem_functor3 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_volatile_mem_functor3( T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_volatile_mem_functor3 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_volatile_mem_functor3( T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
volatile_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_volatile_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_volatile_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
|
|
struct visitor<bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> >
|
|
{
|
|
template <class T_action>
|
|
static void do_visit_each(const T_action& _A_action,
|
|
const bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_target)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor4.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
|
|
class bound_volatile_mem_functor4
|
|
: public volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
{
|
|
typedef volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_volatile_mem_functor4 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_volatile_mem_functor4( T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_volatile_mem_functor4 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_volatile_mem_functor4( T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
volatile_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_volatile_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_volatile_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
|
|
struct visitor<bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> >
|
|
{
|
|
template <class T_action>
|
|
static void do_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)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor5.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
|
|
class bound_volatile_mem_functor5
|
|
: public volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
{
|
|
typedef volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_volatile_mem_functor5 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_volatile_mem_functor5( T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_volatile_mem_functor5 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_volatile_mem_functor5( T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
volatile_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_volatile_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_volatile_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
|
|
struct visitor<bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> >
|
|
{
|
|
template <class T_action>
|
|
static void do_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)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor6.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_arg6 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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 bound_volatile_mem_functor6
|
|
: public volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
{
|
|
typedef volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_volatile_mem_functor6 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_volatile_mem_functor6( T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_volatile_mem_functor6 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_volatile_mem_functor6( T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
volatile_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_volatile_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_volatile_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
struct visitor<bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> >
|
|
{
|
|
template <class T_action>
|
|
static void do_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)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor7.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_arg6 Argument type used in the definition of operator()().
|
|
* - @e T_arg7 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
class bound_volatile_mem_functor7
|
|
: public volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
{
|
|
typedef volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_volatile_mem_functor7 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_volatile_mem_functor7( T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_volatile_mem_functor7 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_volatile_mem_functor7( T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @param _A_a7 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
volatile_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_volatile_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_volatile_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
struct visitor<bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> >
|
|
{
|
|
template <class T_action>
|
|
static void do_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)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor0.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
class bound_const_volatile_mem_functor0
|
|
: public const_volatile_mem_functor0<T_return, T_obj>
|
|
{
|
|
typedef const_volatile_mem_functor0<T_return, T_obj> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_const_volatile_mem_functor0 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_volatile_mem_functor0(const T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_const_volatile_mem_functor0 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_volatile_mem_functor0(const T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()() const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
const_volatile_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_const_volatile_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
struct visitor<bound_const_volatile_mem_functor0<T_return, T_obj> >
|
|
{
|
|
template <class T_action>
|
|
static void do_visit_each(const T_action& _A_action,
|
|
const bound_const_volatile_mem_functor0<T_return, T_obj>& _A_target)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor1.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1>
|
|
class bound_const_volatile_mem_functor1
|
|
: public const_volatile_mem_functor1<T_return, T_obj, T_arg1>
|
|
{
|
|
typedef const_volatile_mem_functor1<T_return, T_obj, T_arg1> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_const_volatile_mem_functor1 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_volatile_mem_functor1(const T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_const_volatile_mem_functor1 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_volatile_mem_functor1(const T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
const_volatile_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_const_volatile_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1>
|
|
struct visitor<bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1> >
|
|
{
|
|
template <class T_action>
|
|
static void do_visit_each(const T_action& _A_action,
|
|
const bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor2.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2>
|
|
class bound_const_volatile_mem_functor2
|
|
: public const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
{
|
|
typedef const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_const_volatile_mem_functor2 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_volatile_mem_functor2(const T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_const_volatile_mem_functor2 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_volatile_mem_functor2(const T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
const_volatile_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_const_volatile_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2>
|
|
struct visitor<bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2> >
|
|
{
|
|
template <class T_action>
|
|
static void do_visit_each(const T_action& _A_action,
|
|
const bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_target)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor3.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
|
|
class bound_const_volatile_mem_functor3
|
|
: public const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
{
|
|
typedef const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_const_volatile_mem_functor3 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_volatile_mem_functor3(const T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_const_volatile_mem_functor3 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_volatile_mem_functor3(const T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
const_volatile_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_const_volatile_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
|
|
struct visitor<bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> >
|
|
{
|
|
template <class T_action>
|
|
static void do_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)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor4.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
|
|
class bound_const_volatile_mem_functor4
|
|
: public const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
{
|
|
typedef const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_const_volatile_mem_functor4 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_volatile_mem_functor4(const T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_const_volatile_mem_functor4 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_volatile_mem_functor4(const T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
const_volatile_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_const_volatile_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
|
|
struct visitor<bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> >
|
|
{
|
|
template <class T_action>
|
|
static void do_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)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor5.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
|
|
class bound_const_volatile_mem_functor5
|
|
: public const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
{
|
|
typedef const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_const_volatile_mem_functor5 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_volatile_mem_functor5(const T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_const_volatile_mem_functor5 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_volatile_mem_functor5(const T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
const_volatile_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_const_volatile_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
|
|
struct visitor<bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> >
|
|
{
|
|
template <class T_action>
|
|
static void do_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)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor6.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_arg6 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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 bound_const_volatile_mem_functor6
|
|
: public const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
{
|
|
typedef const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_const_volatile_mem_functor6 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_volatile_mem_functor6(const T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_const_volatile_mem_functor6 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_volatile_mem_functor6(const T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
const_volatile_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_const_volatile_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
struct visitor<bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> >
|
|
{
|
|
template <class T_action>
|
|
static void do_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)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
/** bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object instance.
|
|
* Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor7.
|
|
*
|
|
* The following template arguments are used:
|
|
* - @e T_arg1 Argument type used in the definition of operator()().
|
|
* - @e T_arg2 Argument type used in the definition of operator()().
|
|
* - @e T_arg3 Argument type used in the definition of operator()().
|
|
* - @e T_arg4 Argument type used in the definition of operator()().
|
|
* - @e T_arg5 Argument type used in the definition of operator()().
|
|
* - @e T_arg6 Argument type used in the definition of operator()().
|
|
* - @e T_arg7 Argument type used in the definition of operator()().
|
|
* - @e T_return The return type of operator()().
|
|
* - @e T_obj The object type.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
class bound_const_volatile_mem_functor7
|
|
: public const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
{
|
|
typedef const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> base_type_;
|
|
public:
|
|
typedef typename base_type_::function_type function_type;
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Constructs a bound_const_volatile_mem_functor7 object that wraps the passed method.
|
|
*
|
|
* @deprecated Please use the constructor that takes the object by reference
|
|
* instead.
|
|
*
|
|
* @param _A_obj Pointer to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_volatile_mem_functor7(const T_obj* _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(*_A_obj)
|
|
{}
|
|
#endif // SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Constructs a bound_const_volatile_mem_functor7 object that wraps the passed method.
|
|
* @param _A_obj Reference to instance the method will operate on.
|
|
* @param _A_func Pointer to method will be invoked from operator()().
|
|
*/
|
|
bound_const_volatile_mem_functor7(const T_obj& _A_obj, function_type _A_func)
|
|
: base_type_(_A_func),
|
|
obj_(_A_obj)
|
|
{}
|
|
|
|
/** Execute the wrapped method operating on the stored instance.
|
|
* @param _A_a1 Argument to be passed on to the method.
|
|
* @param _A_a2 Argument to be passed on to the method.
|
|
* @param _A_a3 Argument to be passed on to the method.
|
|
* @param _A_a4 Argument to be passed on to the method.
|
|
* @param _A_a5 Argument to be passed on to the method.
|
|
* @param _A_a6 Argument to be passed on to the method.
|
|
* @param _A_a7 Argument to be passed on to the method.
|
|
* @return The return value of the method invocation.
|
|
*/
|
|
T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
|
|
{ return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
|
|
|
|
//protected:
|
|
// Reference to stored object instance.
|
|
// This is the handler object, such as TheObject in void TheObject::signal_handler().
|
|
const_volatile_limit_reference<T_obj> obj_;
|
|
};
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
//template specialization of visitor<>::do_visit_each<>(action, functor):
|
|
/** Performs a functor on each of the targets of a functor.
|
|
* The function overload for sigc::bound_const_volatile_mem_functor performs a functor
|
|
* on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
struct visitor<bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> >
|
|
{
|
|
template <class T_action>
|
|
static void do_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)
|
|
{
|
|
sigc::visit_each(_A_action, _A_target.obj_);
|
|
}
|
|
};
|
|
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
// numbered
|
|
/** Creates a functor of type sigc::mem_functor0 which wraps a method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
inline mem_functor0<T_return, T_obj>
|
|
mem_fun0(T_return (T_obj::*_A_func)() )
|
|
{ return mem_functor0<T_return, T_obj>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::mem_functor1 which wraps a method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj>
|
|
inline mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun1(T_return (T_obj::*_A_func)(T_arg1) )
|
|
{ return mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::mem_functor2 which wraps a method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj>
|
|
inline mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun2(T_return (T_obj::*_A_func)(T_arg1, T_arg2) )
|
|
{ return mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::mem_functor3 which wraps a method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
|
|
inline 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) )
|
|
{ return mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::mem_functor4 which wraps a method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
|
|
inline 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) )
|
|
{ return mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::mem_functor5 which wraps a method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
|
|
inline 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) )
|
|
{ return mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::mem_functor6 which wraps a method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline 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) )
|
|
{ return mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::mem_functor7 which wraps a method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline 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) )
|
|
{ return mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_mem_functor0 which wraps a const method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
inline const_mem_functor0<T_return, T_obj>
|
|
mem_fun0(T_return (T_obj::*_A_func)() const)
|
|
{ return const_mem_functor0<T_return, T_obj>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_mem_functor1 which wraps a const method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj>
|
|
inline const_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun1(T_return (T_obj::*_A_func)(T_arg1) const)
|
|
{ return const_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_mem_functor2 which wraps a const method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj>
|
|
inline const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun2(T_return (T_obj::*_A_func)(T_arg1, T_arg2) const)
|
|
{ return const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_mem_functor3 which wraps a const method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
|
|
inline const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
mem_fun3(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) const)
|
|
{ return const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_mem_functor4 which wraps a const method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
|
|
inline const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
mem_fun4(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
|
|
{ return const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_mem_functor5 which wraps a const method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
|
|
inline const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
mem_fun5(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
|
|
{ return const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_mem_functor6 which wraps a const method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
mem_fun6(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
|
|
{ return const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_mem_functor7 which wraps a const method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
mem_fun7(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
|
|
{ return const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::volatile_mem_functor0 which wraps a volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
inline volatile_mem_functor0<T_return, T_obj>
|
|
mem_fun0(T_return (T_obj::*_A_func)() volatile)
|
|
{ return volatile_mem_functor0<T_return, T_obj>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::volatile_mem_functor1 which wraps a volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj>
|
|
inline volatile_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun1(T_return (T_obj::*_A_func)(T_arg1) volatile)
|
|
{ return volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::volatile_mem_functor2 which wraps a volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj>
|
|
inline volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun2(T_return (T_obj::*_A_func)(T_arg1, T_arg2) volatile)
|
|
{ return volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::volatile_mem_functor3 which wraps a volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
|
|
inline volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
mem_fun3(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)
|
|
{ return volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::volatile_mem_functor4 which wraps a volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
|
|
inline volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
mem_fun4(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
|
|
{ return volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::volatile_mem_functor5 which wraps a volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
|
|
inline volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
mem_fun5(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
|
|
{ return volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::volatile_mem_functor6 which wraps a volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
mem_fun6(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
|
|
{ return volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::volatile_mem_functor7 which wraps a volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
mem_fun7(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
|
|
{ return volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_volatile_mem_functor0 which wraps a const volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
inline const_volatile_mem_functor0<T_return, T_obj>
|
|
mem_fun0(T_return (T_obj::*_A_func)() const volatile)
|
|
{ return const_volatile_mem_functor0<T_return, T_obj>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_volatile_mem_functor1 which wraps a const volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj>
|
|
inline const_volatile_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun1(T_return (T_obj::*_A_func)(T_arg1) const volatile)
|
|
{ return const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_volatile_mem_functor2 which wraps a const volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj>
|
|
inline const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun2(T_return (T_obj::*_A_func)(T_arg1, T_arg2) const volatile)
|
|
{ return const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_volatile_mem_functor3 which wraps a const volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
|
|
inline const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
mem_fun3(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)
|
|
{ return const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_volatile_mem_functor4 which wraps a const volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
|
|
inline const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
mem_fun4(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
|
|
{ return const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_volatile_mem_functor5 which wraps a const volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
|
|
inline const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
mem_fun5(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
|
|
{ return const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_volatile_mem_functor6 which wraps a const volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
mem_fun6(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
|
|
{ return const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_volatile_mem_functor7 which wraps a const volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
mem_fun7(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
|
|
{ return const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_mem_functor0 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_obj2>
|
|
inline bound_mem_functor0<T_return, T_obj>
|
|
mem_fun0(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() )
|
|
{ return bound_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_mem_functor0 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_obj2>
|
|
inline bound_mem_functor0<T_return, T_obj>
|
|
mem_fun0(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() )
|
|
{ return bound_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_mem_functor1 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj, class T_obj2>
|
|
inline bound_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun1(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) )
|
|
{ return bound_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_mem_functor1 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj, class T_obj2>
|
|
inline bound_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun1(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) )
|
|
{ return bound_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_mem_functor2 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
|
|
inline 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) )
|
|
{ return bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_mem_functor2 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
|
|
inline 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) )
|
|
{ return bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_mem_functor3 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
|
|
inline 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) )
|
|
{ return bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_mem_functor3 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
|
|
inline 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) )
|
|
{ return bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_mem_functor4 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
|
|
inline 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) )
|
|
{ return bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_mem_functor4 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
|
|
inline 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) )
|
|
{ return bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_mem_functor5 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline 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) )
|
|
{ return bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_mem_functor5 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline 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) )
|
|
{ return bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_mem_functor6 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline 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) )
|
|
{ return bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_mem_functor6 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline 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) )
|
|
{ return bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_mem_functor7 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline 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) )
|
|
{ return bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_mem_functor7 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline 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) )
|
|
{ return bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_mem_functor0 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor0<T_return, T_obj>
|
|
mem_fun0(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() const)
|
|
{ return bound_const_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_mem_functor0 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor0<T_return, T_obj>
|
|
mem_fun0(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() const)
|
|
{ return bound_const_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_mem_functor1 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun1(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const)
|
|
{ return bound_const_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_mem_functor1 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun1(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const)
|
|
{ return bound_const_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_mem_functor2 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun2(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const)
|
|
{ return bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_mem_functor2 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun2(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const)
|
|
{ return bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_mem_functor3 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
mem_fun3(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const)
|
|
{ return bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_mem_functor3 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
mem_fun3(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const)
|
|
{ return bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_mem_functor4 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
mem_fun4(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
|
|
{ return bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_mem_functor4 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
mem_fun4(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
|
|
{ return bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_mem_functor5 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
mem_fun5(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
|
|
{ return bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_mem_functor5 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
mem_fun5(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
|
|
{ return bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_mem_functor6 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
mem_fun6(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
|
|
{ return bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_mem_functor6 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
mem_fun6(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
|
|
{ return bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_mem_functor7 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
mem_fun7(/*const*/ 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)
|
|
{ return bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_mem_functor7 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
mem_fun7(/*const*/ 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)
|
|
{ return bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor0 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor0<T_return, T_obj>
|
|
mem_fun0(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() volatile)
|
|
{ return bound_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor0 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor0<T_return, T_obj>
|
|
mem_fun0(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() volatile)
|
|
{ return bound_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor1 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun1(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) volatile)
|
|
{ return bound_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor1 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun1(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) volatile)
|
|
{ return bound_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor2 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun2(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) volatile)
|
|
{ return bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor2 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun2(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) volatile)
|
|
{ return bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor3 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
mem_fun3(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)
|
|
{ return bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor3 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
mem_fun3(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)
|
|
{ return bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor4 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
mem_fun4(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
|
|
{ return bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor4 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
mem_fun4(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
|
|
{ return bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor5 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
mem_fun5(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
|
|
{ return bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor5 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
mem_fun5(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
|
|
{ return bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor6 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
mem_fun6(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
|
|
{ return bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor6 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
mem_fun6(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
|
|
{ return bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor7 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
mem_fun7(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
|
|
{ return bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor7 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
mem_fun7(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
|
|
{ return bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor0 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor0<T_return, T_obj>
|
|
mem_fun0(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() const volatile)
|
|
{ return bound_const_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor0 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor0<T_return, T_obj>
|
|
mem_fun0(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() const volatile)
|
|
{ return bound_const_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor1 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun1(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const volatile)
|
|
{ return bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor1 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun1(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const volatile)
|
|
{ return bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor2 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun2(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const volatile)
|
|
{ return bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor2 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun2(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const volatile)
|
|
{ return bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor3 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
mem_fun3(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)
|
|
{ return bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor3 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
mem_fun3(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)
|
|
{ return bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor4 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
mem_fun4(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
|
|
{ return bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor4 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
mem_fun4(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
|
|
{ return bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor5 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
mem_fun5(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
|
|
{ return bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor5 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
mem_fun5(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
|
|
{ return bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor6 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
mem_fun6(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
|
|
{ return bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor6 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
mem_fun6(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
|
|
{ return bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor7 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
mem_fun7(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
|
|
{ return bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor7 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
mem_fun7(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
|
|
{ return bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
|
|
|
|
|
|
// unnumbered
|
|
/** Creates a functor of type sigc::mem_functor0 which wraps a method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
inline mem_functor0<T_return, T_obj>
|
|
mem_fun(T_return (T_obj::*_A_func)() )
|
|
{ return mem_functor0<T_return, T_obj>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::mem_functor1 which wraps a method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj>
|
|
inline mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1) )
|
|
{ return mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::mem_functor2 which wraps a method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj>
|
|
inline mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2) )
|
|
{ return mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::mem_functor3 which wraps a method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
|
|
inline 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) )
|
|
{ return mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::mem_functor4 which wraps a method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
|
|
inline 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) )
|
|
{ return mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::mem_functor5 which wraps a method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
|
|
inline 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) )
|
|
{ return mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::mem_functor6 which wraps a method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline 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) )
|
|
{ return mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::mem_functor7 which wraps a method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline 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) )
|
|
{ return mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_mem_functor0 which wraps a const method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
inline const_mem_functor0<T_return, T_obj>
|
|
mem_fun(T_return (T_obj::*_A_func)() const)
|
|
{ return const_mem_functor0<T_return, T_obj>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_mem_functor1 which wraps a const method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj>
|
|
inline const_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1) const)
|
|
{ return const_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_mem_functor2 which wraps a const method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj>
|
|
inline const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2) const)
|
|
{ return const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_mem_functor3 which wraps a const method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
|
|
inline const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) const)
|
|
{ return const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_mem_functor4 which wraps a const method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
|
|
inline const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
|
|
{ return const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_mem_functor5 which wraps a const method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
|
|
inline const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
|
|
{ return const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_mem_functor6 which wraps a const method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
|
|
{ return const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_mem_functor7 which wraps a const method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
|
|
{ return const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::volatile_mem_functor0 which wraps a volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
inline volatile_mem_functor0<T_return, T_obj>
|
|
mem_fun(T_return (T_obj::*_A_func)() volatile)
|
|
{ return volatile_mem_functor0<T_return, T_obj>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::volatile_mem_functor1 which wraps a volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj>
|
|
inline volatile_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1) volatile)
|
|
{ return volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::volatile_mem_functor2 which wraps a volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj>
|
|
inline volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2) volatile)
|
|
{ return volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::volatile_mem_functor3 which wraps a volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
|
|
inline volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)
|
|
{ return volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::volatile_mem_functor4 which wraps a volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
|
|
inline volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
|
|
{ return volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::volatile_mem_functor5 which wraps a volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
|
|
inline volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
|
|
{ return volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::volatile_mem_functor6 which wraps a volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
|
|
{ return volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::volatile_mem_functor7 which wraps a volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
|
|
{ return volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_volatile_mem_functor0 which wraps a const volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj>
|
|
inline const_volatile_mem_functor0<T_return, T_obj>
|
|
mem_fun(T_return (T_obj::*_A_func)() const volatile)
|
|
{ return const_volatile_mem_functor0<T_return, T_obj>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_volatile_mem_functor1 which wraps a const volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj>
|
|
inline const_volatile_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1) const volatile)
|
|
{ return const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_volatile_mem_functor2 which wraps a const volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj>
|
|
inline const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2) const volatile)
|
|
{ return const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_volatile_mem_functor3 which wraps a const volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
|
|
inline const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)
|
|
{ return const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_volatile_mem_functor4 which wraps a const volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
|
|
inline const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
|
|
{ return const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_volatile_mem_functor5 which wraps a const volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
|
|
inline const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
|
|
{ return const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_volatile_mem_functor6 which wraps a const volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
|
|
{ return const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
|
|
|
|
/** Creates a functor of type sigc::const_volatile_mem_functor7 which wraps a const volatile method.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
|
|
{ return const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_mem_functor0 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_obj2>
|
|
inline bound_mem_functor0<T_return, T_obj>
|
|
mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() )
|
|
{ return bound_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_mem_functor0 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_obj2>
|
|
inline bound_mem_functor0<T_return, T_obj>
|
|
mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() )
|
|
{ return bound_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_mem_functor1 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj, class T_obj2>
|
|
inline bound_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) )
|
|
{ return bound_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_mem_functor1 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj, class T_obj2>
|
|
inline bound_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) )
|
|
{ return bound_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_mem_functor2 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
|
|
inline 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) )
|
|
{ return bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_mem_functor2 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
|
|
inline 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) )
|
|
{ return bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_mem_functor3 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
|
|
inline 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) )
|
|
{ return bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_mem_functor3 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
|
|
inline 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) )
|
|
{ return bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_mem_functor4 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
|
|
inline 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) )
|
|
{ return bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_mem_functor4 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
|
|
inline 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) )
|
|
{ return bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_mem_functor5 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline 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) )
|
|
{ return bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_mem_functor5 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline 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) )
|
|
{ return bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_mem_functor6 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline 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) )
|
|
{ return bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_mem_functor6 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline 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) )
|
|
{ return bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_mem_functor7 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline 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) )
|
|
{ return bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_mem_functor7 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline 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) )
|
|
{ return bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_mem_functor0 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor0<T_return, T_obj>
|
|
mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() const)
|
|
{ return bound_const_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_mem_functor0 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor0<T_return, T_obj>
|
|
mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() const)
|
|
{ return bound_const_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_mem_functor1 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const)
|
|
{ return bound_const_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_mem_functor1 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const)
|
|
{ return bound_const_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_mem_functor2 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const)
|
|
{ return bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_mem_functor2 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const)
|
|
{ return bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_mem_functor3 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const)
|
|
{ return bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_mem_functor3 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const)
|
|
{ return bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_mem_functor4 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
|
|
{ return bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_mem_functor4 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
|
|
{ return bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_mem_functor5 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
|
|
{ return bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_mem_functor5 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
|
|
{ return bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_mem_functor6 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
|
|
{ return bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_mem_functor6 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
|
|
{ return bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_mem_functor7 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
mem_fun(/*const*/ 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)
|
|
{ return bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_mem_functor7 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
mem_fun(/*const*/ 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)
|
|
{ return bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor0 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor0<T_return, T_obj>
|
|
mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() volatile)
|
|
{ return bound_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor0 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor0<T_return, T_obj>
|
|
mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() volatile)
|
|
{ return bound_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor1 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) volatile)
|
|
{ return bound_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor1 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) volatile)
|
|
{ return bound_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor2 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) volatile)
|
|
{ return bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor2 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) volatile)
|
|
{ return bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor3 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)
|
|
{ return bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor3 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)
|
|
{ return bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor4 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
|
|
{ return bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor4 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
|
|
inline bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
|
|
{ return bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor5 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
|
|
{ return bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor5 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
|
|
{ return bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor6 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
|
|
{ return bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor6 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
|
|
{ return bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor7 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
|
|
{ return bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_volatile_mem_functor7 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
|
|
{ return bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor0 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor0<T_return, T_obj>
|
|
mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() const volatile)
|
|
{ return bound_const_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor0 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor0<T_return, T_obj>
|
|
mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() const volatile)
|
|
{ return bound_const_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor1 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const volatile)
|
|
{ return bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor1 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>
|
|
mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const volatile)
|
|
{ return bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor2 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const volatile)
|
|
{ return bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor2 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
|
|
mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const volatile)
|
|
{ return bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor3 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)
|
|
{ return bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor3 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
|
|
mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)
|
|
{ return bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor4 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
|
|
{ return bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor4 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
|
|
inline bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
|
|
mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
|
|
{ return bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor5 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
|
|
{ return bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor5 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
|
|
mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
|
|
{ return bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor6 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
|
|
{ return bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor6 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
|
|
mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
|
|
{ return bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
|
|
|
|
#ifndef SIGCXX_DISABLE_DEPRECATED
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor7 which encapsulates a method and an object instance.
|
|
*
|
|
* @deprecated Please use the version that takes the object by reference instead.
|
|
*
|
|
* @param _A_obj Pointer to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
|
|
{ return bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
|
|
#endif //SIGCXX_DISABLE_DEPRECATED
|
|
|
|
/** Creates a functor of type sigc::bound_const_volatile_mem_functor7 which encapsulates a method and an object instance.
|
|
* @param _A_obj Reference to object instance the functor should operate on.
|
|
* @param _A_func Pointer to method that should be wrapped.
|
|
* @return Functor that executes @e _A_func on invokation.
|
|
*
|
|
* @ingroup mem_fun
|
|
*/
|
|
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>
|
|
inline bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
|
|
mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
|
|
{ return bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
|
|
|
|
|
|
} /* namespace sigc */
|
|
#endif /* _SIGC_FUNCTORS_MEM_FUN_H_ */
|