livetrax/libs/sigc++2/sigc++/slot.h

// -*- c++ -*-
/* Do not edit! -- generated file */


#ifndef _SIGC_MACROS_SLOTHM4_
#define _SIGC_MACROS_SLOTHM4_

#include <sigc++/functors/slot.h>

#ifndef LIBSIGC_DISABLE_DEPRECATED

namespace SigC {

// SlotN
/** Converts an arbitrary functor to a unified type which is opaque.
 * Slot0 itself is a functor or to be more precise a closure. It contains
 * a single, arbitrary functor (or closure) that is executed in operator()().
 *
 * The template arguments determine the function signature of operator()():
 * - @e T_return The return type of operator()().
 *
 * To use simply assign the slot to the desired functor. If the functor
 * is not compatible with the parameter list defined with the template
 * arguments compiler errors are triggered. When called the slot
 * will invoke the functor with minimal copies.
 * block() and unblock() can be used to block the functor's invocation
 * from operator()() temporarily.
 *
 * @par Example:
 *   @code
 *   #include <sigc++/slot.h>
 *   void foo(int) {}
 *   SigC::Slot1<void, long> s = SigC::slot(&foo);
 *   s(19);
 *   @endcode
 *
 * @deprecated Use the unnumbered template sigc::slot instead.
 * @ingroup compat
 */
template <class T_return>
class Slot0
  : public ::sigc::slot<T_return>
{
public:
  typedef ::sigc::slot<T_return> parent_type;

  /// Constructs an empty slot.
  Slot0() {}

  /** Constructs a slot from an arbitrary functor.
   * @param _A_func The desired functor the new slot should be assigned to.
   */
  template <class T_functor>
  Slot0(const T_functor& _A_func)
    : ::sigc::slot<T_return>(_A_func) {}

  /** Constructs a slot, copying an existing one.
   * @param src The existing slot to copy.
   */
  Slot0(const parent_type& src)
    : parent_type(src) {}

  /** Overrides this slot making a copy from another slot.
   * @param src The slot from which to make a copy.
   * @return @p this.
   */
  Slot0& operator=(const parent_type& src)
    { parent_type::operator=(src); return *this; }
};

/** Converts an arbitrary functor to a unified type which is opaque.
 * Slot1 itself is a functor or to be more precise a closure. It contains
 * a single, arbitrary functor (or closure) that is executed in operator()().
 *
 * The template arguments determine the function signature of operator()():
 * - @e T_return The return type of operator()().
 * - @e T_arg1 Argument type used in the definition of operator()().
 *
 * To use simply assign the slot to the desired functor. If the functor
 * is not compatible with the parameter list defined with the template
 * arguments compiler errors are triggered. When called the slot
 * will invoke the functor with minimal copies.
 * block() and unblock() can be used to block the functor's invocation
 * from operator()() temporarily.
 *
 * @par Example:
 *   @code
 *   #include <sigc++/slot.h>
 *   void foo(int) {}
 *   SigC::Slot1<void, long> s = SigC::slot(&foo);
 *   s(19);
 *   @endcode
 *
 * @deprecated Use the unnumbered template sigc::slot instead.
 * @ingroup compat
 */
template <class T_return, class T_arg1>
class Slot1
  : public ::sigc::slot<T_return, T_arg1>
{
public:
  typedef ::sigc::slot<T_return, T_arg1> parent_type;

  /// Constructs an empty slot.
  Slot1() {}

  /** Constructs a slot from an arbitrary functor.
   * @param _A_func The desired functor the new slot should be assigned to.
   */
  template <class T_functor>
  Slot1(const T_functor& _A_func)
    : ::sigc::slot<T_return, T_arg1>(_A_func) {}

  /** Constructs a slot, copying an existing one.
   * @param src The existing slot to copy.
   */
  Slot1(const parent_type& src)
    : parent_type(src) {}

  /** Overrides this slot making a copy from another slot.
   * @param src The slot from which to make a copy.
   * @return @p this.
   */
  Slot1& operator=(const parent_type& src)
    { parent_type::operator=(src); return *this; }
};

/** Converts an arbitrary functor to a unified type which is opaque.
 * Slot2 itself is a functor or to be more precise a closure. It contains
 * a single, arbitrary functor (or closure) that is executed in operator()().
 *
 * The template arguments determine the function signature of operator()():
 * - @e T_return The return type of operator()().
 * - @e T_arg1 Argument type used in the definition of operator()().
 * - @e T_arg2 Argument type used in the definition of operator()().
 *
 * To use simply assign the slot to the desired functor. If the functor
 * is not compatible with the parameter list defined with the template
 * arguments compiler errors are triggered. When called the slot
 * will invoke the functor with minimal copies.
 * block() and unblock() can be used to block the functor's invocation
 * from operator()() temporarily.
 *
 * @par Example:
 *   @code
 *   #include <sigc++/slot.h>
 *   void foo(int) {}
 *   SigC::Slot1<void, long> s = SigC::slot(&foo);
 *   s(19);
 *   @endcode
 *
 * @deprecated Use the unnumbered template sigc::slot instead.
 * @ingroup compat
 */
template <class T_return, class T_arg1,class T_arg2>
class Slot2
  : public ::sigc::slot<T_return, T_arg1,T_arg2>
{
public:
  typedef ::sigc::slot<T_return, T_arg1,T_arg2> parent_type;

  /// Constructs an empty slot.
  Slot2() {}

  /** Constructs a slot from an arbitrary functor.
   * @param _A_func The desired functor the new slot should be assigned to.
   */
  template <class T_functor>
  Slot2(const T_functor& _A_func)
    : ::sigc::slot<T_return, T_arg1,T_arg2>(_A_func) {}

  /** Constructs a slot, copying an existing one.
   * @param src The existing slot to copy.
   */
  Slot2(const parent_type& src)
    : parent_type(src) {}

  /** Overrides this slot making a copy from another slot.
   * @param src The slot from which to make a copy.
   * @return @p this.
   */
  Slot2& operator=(const parent_type& src)
    { parent_type::operator=(src); return *this; }
};

/** Converts an arbitrary functor to a unified type which is opaque.
 * Slot3 itself is a functor or to be more precise a closure. It contains
 * a single, arbitrary functor (or closure) that is executed in operator()().
 *
 * The template arguments determine the function signature of operator()():
 * - @e T_return The return type of operator()().
 * - @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()().
 *
 * To use simply assign the slot to the desired functor. If the functor
 * is not compatible with the parameter list defined with the template
 * arguments compiler errors are triggered. When called the slot
 * will invoke the functor with minimal copies.
 * block() and unblock() can be used to block the functor's invocation
 * from operator()() temporarily.
 *
 * @par Example:
 *   @code
 *   #include <sigc++/slot.h>
 *   void foo(int) {}
 *   SigC::Slot1<void, long> s = SigC::slot(&foo);
 *   s(19);
 *   @endcode
 *
 * @deprecated Use the unnumbered template sigc::slot instead.
 * @ingroup compat
 */
template <class T_return, class T_arg1,class T_arg2,class T_arg3>
class Slot3
  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3>
{
public:
  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3> parent_type;

  /// Constructs an empty slot.
  Slot3() {}

  /** Constructs a slot from an arbitrary functor.
   * @param _A_func The desired functor the new slot should be assigned to.
   */
  template <class T_functor>
  Slot3(const T_functor& _A_func)
    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3>(_A_func) {}

  /** Constructs a slot, copying an existing one.
   * @param src The existing slot to copy.
   */
  Slot3(const parent_type& src)
    : parent_type(src) {}

  /** Overrides this slot making a copy from another slot.
   * @param src The slot from which to make a copy.
   * @return @p this.
   */
  Slot3& operator=(const parent_type& src)
    { parent_type::operator=(src); return *this; }
};

/** Converts an arbitrary functor to a unified type which is opaque.
 * Slot4 itself is a functor or to be more precise a closure. It contains
 * a single, arbitrary functor (or closure) that is executed in operator()().
 *
 * The template arguments determine the function signature of operator()():
 * - @e T_return The return type of operator()().
 * - @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()().
 *
 * To use simply assign the slot to the desired functor. If the functor
 * is not compatible with the parameter list defined with the template
 * arguments compiler errors are triggered. When called the slot
 * will invoke the functor with minimal copies.
 * block() and unblock() can be used to block the functor's invocation
 * from operator()() temporarily.
 *
 * @par Example:
 *   @code
 *   #include <sigc++/slot.h>
 *   void foo(int) {}
 *   SigC::Slot1<void, long> s = SigC::slot(&foo);
 *   s(19);
 *   @endcode
 *
 * @deprecated Use the unnumbered template sigc::slot instead.
 * @ingroup compat
 */
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
class Slot4
  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
{
public:
  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4> parent_type;

  /// Constructs an empty slot.
  Slot4() {}

  /** Constructs a slot from an arbitrary functor.
   * @param _A_func The desired functor the new slot should be assigned to.
   */
  template <class T_functor>
  Slot4(const T_functor& _A_func)
    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func) {}

  /** Constructs a slot, copying an existing one.
   * @param src The existing slot to copy.
   */
  Slot4(const parent_type& src)
    : parent_type(src) {}

  /** Overrides this slot making a copy from another slot.
   * @param src The slot from which to make a copy.
   * @return @p this.
   */
  Slot4& operator=(const parent_type& src)
    { parent_type::operator=(src); return *this; }
};

/** Converts an arbitrary functor to a unified type which is opaque.
 * Slot5 itself is a functor or to be more precise a closure. It contains
 * a single, arbitrary functor (or closure) that is executed in operator()().
 *
 * The template arguments determine the function signature of operator()():
 * - @e T_return The return type of operator()().
 * - @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()().
 *
 * To use simply assign the slot to the desired functor. If the functor
 * is not compatible with the parameter list defined with the template
 * arguments compiler errors are triggered. When called the slot
 * will invoke the functor with minimal copies.
 * block() and unblock() can be used to block the functor's invocation
 * from operator()() temporarily.
 *
 * @par Example:
 *   @code
 *   #include <sigc++/slot.h>
 *   void foo(int) {}
 *   SigC::Slot1<void, long> s = SigC::slot(&foo);
 *   s(19);
 *   @endcode
 *
 * @deprecated Use the unnumbered template sigc::slot instead.
 * @ingroup compat
 */
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
class Slot5
  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
{
public:
  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> parent_type;

  /// Constructs an empty slot.
  Slot5() {}

  /** Constructs a slot from an arbitrary functor.
   * @param _A_func The desired functor the new slot should be assigned to.
   */
  template <class T_functor>
  Slot5(const T_functor& _A_func)
    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_func) {}

  /** Constructs a slot, copying an existing one.
   * @param src The existing slot to copy.
   */
  Slot5(const parent_type& src)
    : parent_type(src) {}

  /** Overrides this slot making a copy from another slot.
   * @param src The slot from which to make a copy.
   * @return @p this.
   */
  Slot5& operator=(const parent_type& src)
    { parent_type::operator=(src); return *this; }
};

/** Converts an arbitrary functor to a unified type which is opaque.
 * Slot6 itself is a functor or to be more precise a closure. It contains
 * a single, arbitrary functor (or closure) that is executed in operator()().
 *
 * The template arguments determine the function signature of operator()():
 * - @e T_return The return type of operator()().
 * - @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()().
 *
 * To use simply assign the slot to the desired functor. If the functor
 * is not compatible with the parameter list defined with the template
 * arguments compiler errors are triggered. When called the slot
 * will invoke the functor with minimal copies.
 * block() and unblock() can be used to block the functor's invocation
 * from operator()() temporarily.
 *
 * @par Example:
 *   @code
 *   #include <sigc++/slot.h>
 *   void foo(int) {}
 *   SigC::Slot1<void, long> s = SigC::slot(&foo);
 *   s(19);
 *   @endcode
 *
 * @deprecated Use the unnumbered template sigc::slot instead.
 * @ingroup compat
 */
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
class Slot6
  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
{
public:
  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> parent_type;

  /// Constructs an empty slot.
  Slot6() {}

  /** Constructs a slot from an arbitrary functor.
   * @param _A_func The desired functor the new slot should be assigned to.
   */
  template <class T_functor>
  Slot6(const T_functor& _A_func)
    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_func) {}

  /** Constructs a slot, copying an existing one.
   * @param src The existing slot to copy.
   */
  Slot6(const parent_type& src)
    : parent_type(src) {}

  /** Overrides this slot making a copy from another slot.
   * @param src The slot from which to make a copy.
   * @return @p this.
   */
  Slot6& operator=(const parent_type& src)
    { parent_type::operator=(src); return *this; }
};

/** Converts an arbitrary functor to a unified type which is opaque.
 * Slot7 itself is a functor or to be more precise a closure. It contains
 * a single, arbitrary functor (or closure) that is executed in operator()().
 *
 * The template arguments determine the function signature of operator()():
 * - @e T_return The return type of operator()().
 * - @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()().
 *
 * To use simply assign the slot to the desired functor. If the functor
 * is not compatible with the parameter list defined with the template
 * arguments compiler errors are triggered. When called the slot
 * will invoke the functor with minimal copies.
 * block() and unblock() can be used to block the functor's invocation
 * from operator()() temporarily.
 *
 * @par Example:
 *   @code
 *   #include <sigc++/slot.h>
 *   void foo(int) {}
 *   SigC::Slot1<void, long> s = SigC::slot(&foo);
 *   s(19);
 *   @endcode
 *
 * @deprecated Use the unnumbered template sigc::slot instead.
 * @ingroup compat
 */
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
class Slot7
  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
{
public:
  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> parent_type;

  /// Constructs an empty slot.
  Slot7() {}

  /** Constructs a slot from an arbitrary functor.
   * @param _A_func The desired functor the new slot should be assigned to.
   */
  template <class T_functor>
  Slot7(const T_functor& _A_func)
    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_func) {}

  /** Constructs a slot, copying an existing one.
   * @param src The existing slot to copy.
   */
  Slot7(const parent_type& src)
    : parent_type(src) {}

  /** Overrides this slot making a copy from another slot.
   * @param src The slot from which to make a copy.
   * @return @p this.
   */
  Slot7& operator=(const parent_type& src)
    { parent_type::operator=(src); return *this; }
};



#ifndef DOXYGEN_SHOULD_SKIP_THIS
/* gcc 3.2 reports a strange conflict between SigC::slot() and sigc::slot<>
 * when "using namespace SigC" and later using a slot(obj,func) overload
 * without the prefix "SigC::". Probably a compiler bug. I will investigate.
 *
 * This ugly hack avoids the error:
 */
// #define slot(...) make_slot(__VA_ARGS__) /* only works for gcc */
#endif


// slot()
/** Creates a functor of type SigC::Slot0 that wraps an existing non-member function.
 *
 * @param _A_func Pointer to function that should be wrapped.
 * @return Functor that executes _A_func on invokation.
 *
 * @deprecated Use sigc::ptr_fun() instead.
 * @ingroup compat
 */
template <class T_return>
inline Slot0<T_return>
slot(T_return (*_A_func)())
{ return Slot0<T_return>(_A_func); }

/** Creates a functor of type SigC::Slot1 that wraps an existing non-member function.
 *
 * @param _A_func Pointer to function that should be wrapped.
 * @return Functor that executes _A_func on invokation.
 *
 * @deprecated Use sigc::ptr_fun() instead.
 * @ingroup compat
 */
template <class T_return, class T_arg1>
inline Slot1<T_return, T_arg1>
slot(T_return (*_A_func)(T_arg1))
{ return Slot1<T_return, T_arg1>(_A_func); }

/** Creates a functor of type SigC::Slot2 that wraps an existing non-member function.
 *
 * @param _A_func Pointer to function that should be wrapped.
 * @return Functor that executes _A_func on invokation.
 *
 * @deprecated Use sigc::ptr_fun() instead.
 * @ingroup compat
 */
template <class T_return, class T_arg1,class T_arg2>
inline Slot2<T_return, T_arg1,T_arg2>
slot(T_return (*_A_func)(T_arg1,T_arg2))
{ return Slot2<T_return, T_arg1,T_arg2>(_A_func); }

/** Creates a functor of type SigC::Slot3 that wraps an existing non-member function.
 *
 * @param _A_func Pointer to function that should be wrapped.
 * @return Functor that executes _A_func on invokation.
 *
 * @deprecated Use sigc::ptr_fun() instead.
 * @ingroup compat
 */
template <class T_return, class T_arg1,class T_arg2,class T_arg3>
inline Slot3<T_return, T_arg1,T_arg2,T_arg3>
slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3))
{ return Slot3<T_return, T_arg1,T_arg2,T_arg3>(_A_func); }

/** Creates a functor of type SigC::Slot4 that wraps an existing non-member function.
 *
 * @param _A_func Pointer to function that should be wrapped.
 * @return Functor that executes _A_func on invokation.
 *
 * @deprecated Use sigc::ptr_fun() instead.
 * @ingroup compat
 */
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
inline Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4))
{ return Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func); }

/** Creates a functor of type SigC::Slot5 that wraps an existing non-member function.
 *
 * @param _A_func Pointer to function that should be wrapped.
 * @return Functor that executes _A_func on invokation.
 *
 * @deprecated Use sigc::ptr_fun() instead.
 * @ingroup compat
 */
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
inline Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5))
{ return Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_func); }

/** Creates a functor of type SigC::Slot6 that wraps an existing non-member function.
 *
 * @param _A_func Pointer to function that should be wrapped.
 * @return Functor that executes _A_func on invokation.
 *
 * @deprecated Use sigc::ptr_fun() instead.
 * @ingroup compat
 */
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
inline Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6))
{ return Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_func); }

/** Creates a functor of type SigC::Slot7 that wraps an existing non-member function.
 *
 * @param _A_func Pointer to function that should be wrapped.
 * @return Functor that executes _A_func on invokation.
 *
 * @deprecated Use sigc::ptr_fun() instead.
 * @ingroup compat
 */
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
inline Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7))
{ return Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_func); }



}

#endif
#endif /* _SIGC_MACROS_SLOTHM4_ */