Import libsigc++ 2.10.8 sources

[ext/sigc++-2.0.git] / untracked / sigc++ / signal.h

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

#ifndef _SIGC_SIGNAL_H_
#define _SIGC_SIGNAL_H_

#include <list>
#include <sigc++/signal_base.h>
#include <sigc++/type_traits.h>
#include <sigc++/trackable.h>
#include <sigc++/functors/slot.h>
#include <sigc++/functors/mem_fun.h>

//TODO: See comment in functor_trait.h.
#if defined(nil) && defined(SIGC_PRAGMA_PUSH_POP_MACRO)
  #define SIGC_NIL_HAS_BEEN_PUSHED 1
  #pragma push_macro("nil")
  #undef nil
#endif

//SIGC_TYPEDEF_REDEFINE_ALLOWED:
// TODO: This should have its own test, but I can not create one that gives the error instead of just a warning. murrayc.
// I have just used this because there is a correlation between these two problems.
#ifdef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  //Compilers, such as older versions of SUN Forte C++, that do not allow this also often
  //do not allow a typedef to have the same name as a class in the typedef's definition.
  //For Sun Forte CC 5.7 (SUN Workshop 10), comment this out to fix the build.
  #define SIGC_TYPEDEF_REDEFINE_ALLOWED 1
#endif

namespace sigc {

/** STL-style iterator for slot_list.
 *
 * @ingroup signal
 */
template <typename T_slot>
struct slot_iterator
{
  typedef std::size_t                     size_type;
  typedef std::ptrdiff_t                  difference_type;
  typedef std::bidirectional_iterator_tag iterator_category;

  typedef T_slot  slot_type;

  typedef T_slot  value_type;
  typedef T_slot* pointer;
  typedef T_slot& reference;

  typedef typename internal::signal_impl::iterator_type iterator_type;

  slot_iterator()
    {}

  explicit slot_iterator(const iterator_type& i)
    : i_(i) {}

  reference operator*() const
    { return static_cast<reference>(*i_); }

  pointer operator->() const
    { return &(operator*()); }

  slot_iterator& operator++()
    {
      ++i_;
      return *this;
    }

  slot_iterator operator++(int)
    { 
      slot_iterator __tmp(*this);
      ++i_;
      return __tmp;
    }

  slot_iterator& operator--()
    {
      --i_;
      return *this;
    }

  slot_iterator operator--(int)
    {
      slot_iterator __tmp(*this);
      --i_;
      return __tmp;
    }

  bool operator == (const slot_iterator& other) const
    { return i_ == other.i_; }

  bool operator != (const slot_iterator& other) const
    { return i_ != other.i_; }

  iterator_type i_;
};

/** STL-style const iterator for slot_list.
 *
 * @ingroup signal
 */
template <typename T_slot>
struct slot_const_iterator
{
  typedef std::size_t                     size_type;
  typedef std::ptrdiff_t                  difference_type;
  typedef std::bidirectional_iterator_tag iterator_category;

  typedef T_slot        slot_type;

  typedef T_slot        value_type;
  typedef const T_slot* pointer;
  typedef const T_slot& reference;

  typedef typename internal::signal_impl::const_iterator_type iterator_type;

  slot_const_iterator()
    {}

  explicit slot_const_iterator(const iterator_type& i)
    : i_(i) {}

  reference operator*() const
    { return static_cast<reference>(*i_); }

  pointer operator->() const
    { return &(operator*()); }

  slot_const_iterator& operator++()
    {
      ++i_;
      return *this;
    }

  slot_const_iterator operator++(int)
    { 
      slot_const_iterator __tmp(*this);
      ++i_;
      return __tmp;
    }

  slot_const_iterator& operator--()
    {
      --i_;
      return *this;
    }

  slot_const_iterator operator--(int)
    {
      slot_const_iterator __tmp(*this);
      --i_;
      return __tmp;
    }

  bool operator == (const slot_const_iterator& other) const
    { return i_ == other.i_; }

  bool operator != (const slot_const_iterator& other) const
    { return i_ != other.i_; }

  iterator_type i_;
};

/** STL-style list interface for sigc::signal#.
 * slot_list can be used to iterate over the list of slots that
 * is managed by a signal. Slots can be added or removed from
 * the list while existing iterators stay valid.
 *
 * @ingroup signal
 */
template <class T_slot>
struct slot_list
{
  typedef T_slot slot_type;

  typedef slot_type&       reference;
  typedef const slot_type& const_reference;

  typedef slot_iterator<slot_type>              iterator;
  typedef slot_const_iterator<slot_type>        const_iterator;
  
  #ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
  typedef std::reverse_iterator<iterator>       reverse_iterator;
  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
  #else
  typedef std::reverse_iterator<iterator, std::random_access_iterator_tag,
                                int, int&, int*, std::ptrdiff_t> reverse_iterator;

  typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag,
                                int, const int&, const int*, std::ptrdiff_t> const_reverse_iterator;
  #endif /* SIGC_HAVE_SUN_REVERSE_ITERATOR */


  slot_list()
    : list_(nullptr) {}

  explicit slot_list(internal::signal_impl* __list)
    : list_(__list) {}

  iterator begin()
    { return iterator(list_->slots_.begin()); }

  const_iterator begin() const
    { return const_iterator(list_->slots_.begin()); }

  iterator end()
    { return iterator(list_->slots_.end()); }

  const_iterator end() const
    { return const_iterator(list_->slots_.end()); }

  reverse_iterator rbegin() 
    { return reverse_iterator(end()); }

  const_reverse_iterator rbegin() const 
    { return const_reverse_iterator(end()); }

  reverse_iterator rend()
    { return reverse_iterator(begin()); }

  const_reverse_iterator rend() const
    { return const_reverse_iterator(begin()); }

  reference front()
    { return *begin(); }

  const_reference front() const
    { return *begin(); }

  reference back()
    { return *(--end()); }

  const_reference back() const
    { return *(--end()); }

  iterator insert(iterator i, const slot_type& slot_)
    { return iterator(list_->insert(i.i_, static_cast<const slot_base&>(slot_))); }

  iterator insert(iterator i, slot_type&& slot_)
    { return iterator(list_->insert(i.i_, std::move(static_cast<slot_base&>(slot_)))); }

  void push_front(const slot_type& c)
    { insert(begin(), c); }

  void push_front(slot_type&& c)
    { insert(begin(), std::move(c)); }

  void push_back(const slot_type& c)
    { insert(end(), c); }

  void push_back(slot_type&& c)
    { insert(end(), std::move(c)); }

  iterator erase(iterator i)
    { return iterator(list_->erase(i.i_)); }

  iterator erase(iterator first_, iterator last_)
    {
      while (first_ != last_)
        first_ = erase(first_);
      return last_;
    }

  void pop_front()
    { erase(begin()); }

  void pop_back()
    { 
      auto tmp_ = end();
      erase(--tmp_);
    }

protected:
  internal::signal_impl* list_;
};


namespace internal {

/** Special iterator over sigc::internal::signal_impl's slot list that holds extra data.
 * This iterators is for use in accumulators. operator*() executes
 * the slot. The return value is buffered, so that in an expression
 * like @code a = (*i) * (*i); @endcode the slot is executed only once.
 */
template <class T_emitter, class T_result = typename T_emitter::result_type>
struct slot_iterator_buf
{
  typedef std::size_t                      size_type;
  typedef std::ptrdiff_t                   difference_type;
  typedef std::bidirectional_iterator_tag  iterator_category;

  //These are needed just to make this a proper C++ iterator, 
  //that can be used with standard C++ algorithms.
  typedef T_result                         value_type;
  typedef T_result&                        reference;
  typedef T_result*                        pointer;

  typedef T_emitter                        emitter_type;
  typedef T_result                         result_type;
  typedef typename T_emitter::slot_type    slot_type;

  typedef signal_impl::const_iterator_type iterator_type;

  slot_iterator_buf()
    : c_(nullptr), invoked_(false) {}

  slot_iterator_buf(const iterator_type& i, const emitter_type* c)
    : i_(i), c_(c), invoked_(false) {}

  result_type operator*() const
    {
      if (!i_->empty() && !i_->blocked() && !invoked_)
        {
          r_ = (*c_)(static_cast<const slot_type&>(*i_));
          invoked_ = true;
        }
      return r_;
    }

  slot_iterator_buf& operator++()
    {
      ++i_;
      invoked_ = false;
      return *this;
    }

  slot_iterator_buf operator++(int)
    { 
      slot_iterator_buf __tmp(*this);
      ++i_;
      invoked_ = false;
      return __tmp;
    }

  slot_iterator_buf& operator--()
    {
      --i_;
      invoked_ = false;
      return *this;
    }

  slot_iterator_buf operator--(int)
    {
      slot_iterator_buf __tmp(*this);
      --i_;
      invoked_ = false;
      return __tmp;
    }

  bool operator == (const slot_iterator_buf& other) const
    { return (!c_ || (i_ == other.i_)); } /* If '!c_' the iterators are empty.
                                           * Unfortunately, empty stl iterators are not equal.
                                           * We are forcing equality so that 'first==last'
                                           * in the accumulator's emit function yields true. */

  bool operator != (const slot_iterator_buf& other) const
    { return (c_ && (i_ != other.i_)); }

private:
  iterator_type i_;
  const emitter_type* c_;
  mutable result_type r_;
  mutable bool invoked_;
};

/** Template specialization of slot_iterator_buf for void return signals.
 */
template <class T_emitter>
struct slot_iterator_buf<T_emitter, void>
{
  typedef std::size_t                      size_type;
  typedef std::ptrdiff_t                   difference_type;
  typedef std::bidirectional_iterator_tag  iterator_category;

  typedef T_emitter                        emitter_type;
  typedef void                             result_type;
  typedef typename T_emitter::slot_type    slot_type;

  typedef signal_impl::const_iterator_type iterator_type;

  slot_iterator_buf()
    : c_(nullptr), invoked_(false) {}

  slot_iterator_buf(const iterator_type& i, const emitter_type* c)
    : i_(i), c_(c), invoked_(false) {}

  void operator*() const
    {
      if (!i_->empty() && !i_->blocked() && !invoked_)
        {
          (*c_)(static_cast<const slot_type&>(*i_));
          invoked_ = true;
        }
    }

  slot_iterator_buf& operator++()
    {
      ++i_;
      invoked_ = false;
      return *this;
    }

  slot_iterator_buf operator++(int)
    { 
      slot_iterator_buf __tmp(*this);
      ++i_;
      invoked_ = false;
      return __tmp;
    }

  slot_iterator_buf& operator--()
    {
      --i_;
      invoked_ = false;
      return *this;
    }

  slot_iterator_buf operator--(int)
    {
      slot_iterator_buf __tmp(*this);
      --i_;
      invoked_ = false;
      return __tmp;
    }

  bool operator == (const slot_iterator_buf& other) const
    { return i_ == other.i_; }

  bool operator != (const slot_iterator_buf& other) const
    { return i_ != other.i_; }

private:
  iterator_type i_;
  const emitter_type* c_;
  mutable bool invoked_;
};

/** Reverse version of sigc::internal::slot_iterator_buf. */
template <class T_emitter, class T_result = typename T_emitter::result_type>
struct slot_reverse_iterator_buf
{
  typedef std::size_t                      size_type;
  typedef std::ptrdiff_t                   difference_type;
  typedef std::bidirectional_iterator_tag  iterator_category;

  //These are needed just to make this a proper C++ iterator, 
  //that can be used with standard C++ algorithms.
  typedef T_result                         value_type;
  typedef T_result&                        reference;
  typedef T_result*                        pointer;

  typedef T_emitter                        emitter_type;
  typedef T_result                         result_type;
  typedef typename T_emitter::slot_type    slot_type;

  typedef signal_impl::const_iterator_type iterator_type;

  slot_reverse_iterator_buf()
    : c_(nullptr), invoked_(false) {}

  slot_reverse_iterator_buf(const iterator_type& i, const emitter_type* c)
    : i_(i), c_(c), invoked_(false) {}

  result_type operator*() const
    {
      auto __tmp(i_);
          --__tmp;
      if (!__tmp->empty() && !__tmp->blocked() && !invoked_)
        {
          r_ = (*c_)(static_cast<const slot_type&>(*__tmp));
          invoked_ = true;
        }
      return r_;
    }

  slot_reverse_iterator_buf& operator++()
    {
      --i_;
      invoked_ = false;
      return *this;
    }

  slot_reverse_iterator_buf operator++(int)
    { 
      slot_reverse_iterator_buf __tmp(*this);
      --i_;
      invoked_ = false;
      return __tmp;
    }

  slot_reverse_iterator_buf& operator--()
    {
      ++i_;
      invoked_ = false;
      return *this;
    }

  slot_reverse_iterator_buf operator--(int)
    {
      slot_reverse_iterator_buf __tmp(*this);
      ++i_;
      invoked_ = false;
      return __tmp;
    }

  bool operator == (const slot_reverse_iterator_buf& other) const
    { return (!c_ || (i_ == other.i_)); } /* If '!c_' the iterators are empty.
                                           * Unfortunately, empty stl iterators are not equal.
                                           * We are forcing equality so that 'first==last'
                                           * in the accumulator's emit function yields true. */

  bool operator != (const slot_reverse_iterator_buf& other) const
    { return (c_ && (i_ != other.i_)); }

private:
  iterator_type i_;
  const emitter_type* c_;
  mutable result_type r_;
  mutable bool invoked_;
};

/** Template specialization of slot_reverse_iterator_buf for void return signals.
 */
template <class T_emitter>
struct slot_reverse_iterator_buf<T_emitter, void>
{
  typedef std::size_t                      size_type;
  typedef std::ptrdiff_t                   difference_type;
  typedef std::bidirectional_iterator_tag  iterator_category;

  typedef T_emitter                        emitter_type;
  typedef void                             result_type;
  typedef typename T_emitter::slot_type    slot_type;

  typedef signal_impl::const_iterator_type iterator_type;

  slot_reverse_iterator_buf()
    : c_(nullptr), invoked_(false) {}

  slot_reverse_iterator_buf(const iterator_type& i, const emitter_type* c)
    : i_(i), c_(c), invoked_(false) {}

  void operator*() const
    {
      auto __tmp(i_);
          --__tmp;
          if (!__tmp->empty() && !__tmp->blocked() && !invoked_)
        {
          (*c_)(static_cast<const slot_type&>(*__tmp));
          invoked_ = true;
        }
    }

  slot_reverse_iterator_buf& operator++()
    {
      --i_;
      invoked_ = false;
      return *this;
    }

  slot_reverse_iterator_buf operator++(int)
    { 
      slot_reverse_iterator_buf __tmp(*this);
      --i_;
      invoked_ = false;
      return __tmp;
    }

  slot_reverse_iterator_buf& operator--()
    {
      ++i_;
      invoked_ = false;
      return *this;
    }

  slot_reverse_iterator_buf operator--(int)
    {
      slot_reverse_iterator_buf __tmp(*this);
      ++i_;
      invoked_ = false;
      return __tmp;
    }

  bool operator == (const slot_reverse_iterator_buf& other) const
    { return i_ == other.i_; }

  bool operator != (const slot_reverse_iterator_buf& other) const
    { return i_ != other.i_; }

private:
  iterator_type i_;
  const emitter_type* c_;
  mutable bool invoked_;
};

/** Abstracts signal emission.
 * This template implements the emit() function of signal0.
 * Template specializations are available to optimize signal
 * emission when no accumulator is used, for example when the template
 * argument @e T_accumulator is @p nil.
 */
template <class T_return, class T_accumulator>
struct signal_emit0
{
  typedef signal_emit0<T_return, T_accumulator> self_type;
  typedef typename T_accumulator::result_type result_type;
  typedef slot<T_return()> slot_type;
  typedef internal::slot_iterator_buf<self_type, T_return> slot_iterator_buf_type;
  typedef internal::slot_reverse_iterator_buf<self_type, T_return> slot_reverse_iterator_buf_type;
  typedef signal_impl::const_iterator_type iterator_type;

  signal_emit0()  {}

  /** Invokes a slot.
   * @param _A_slot Some slot to invoke.
   * @return The slot's return value.
   */
  T_return operator()(const slot_type& _A_slot) const
    { return (sigc::internal::function_pointer_cast<typename slot_type::call_type>(_A_slot.rep_->call_))(_A_slot.rep_); }

  /** Executes a list of slots using an accumulator of type @e T_accumulator.

   * @return The accumulated return values of the slot invocations as processed by the accumulator.
   */
  static result_type emit(signal_impl* impl)
    {
      T_accumulator accumulator;

      if (!impl)
        return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());

      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      self_type self ;
      return accumulator(slot_iterator_buf_type(slots.begin(), &self),
                         slot_iterator_buf_type(slots.end(), &self));
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.

   * @return The accumulated return values of the slot invocations as processed by the accumulator.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl)
    {
      T_accumulator accumulator;

      if (!impl)
        return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());

      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      self_type self ;
      return accumulator(slot_reverse_iterator_buf_type(slots.end(), &self),
                         slot_reverse_iterator_buf_type(slots.begin(), &self));
    }
#endif // SIGCXX_DISABLE_DEPRECATED

  
};

/** Abstracts signal emission.
 * This template specialization implements an optimized emit()
 * function for the case that no accumulator is used.
 */
template <class T_return>
struct signal_emit0<T_return, nil>
{
  typedef signal_emit0<T_return, nil > self_type;
  typedef T_return result_type;
  typedef slot<T_return()> slot_type;
  typedef signal_impl::const_iterator_type iterator_type;
  typedef typename slot_type::call_type call_type;

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The return value of the last slot invoked is returned.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @return The return value of the last slot invoked.
   */
  static result_type emit(signal_impl* impl)
    {
      if (!impl || impl->slots_.empty())
        return T_return();
        
      signal_exec exec(impl);
      T_return r_ = T_return(); 
      
      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
      { 
        temp_slot_list slots(impl->slots_);
        auto it = slots.begin();
        for (; it != slots.end(); ++it)
          if (!it->empty() && !it->blocked()) break;
          
        if (it == slots.end())
          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
  
        r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_);
        for (++it; it != slots.end(); ++it)
          {
            if (it->empty() || it->blocked())
              continue;
            r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_);
          }
      }
      
      return r_;
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The return value of the last slot invoked is returned.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @return The return value of the last slot invoked.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl)
    {
      if (!impl || impl->slots_.empty())
        return T_return();
        
      signal_exec exec(impl);
      T_return r_ = T_return(); 
      
      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
      { 
#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
        typedef std::reverse_iterator<signal_impl::iterator_type> reverse_iterator_type;
#else
        typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
                                       slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
#endif

        temp_slot_list slots(impl->slots_);
        reverse_iterator_type it(slots.end());
        for (; it != reverse_iterator_type(slots.begin()); ++it)
          if (!it->empty() && !it->blocked()) break;
          
        if (it == reverse_iterator_type(slots.begin()))
          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
  
        r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_);
        for (++it; it != reverse_iterator_type(slots.begin()); ++it)
          {
            if (it->empty() || it->blocked())
              continue;
            r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_);
          }
      }
      
      return r_;
    }
#endif // SIGCXX_DISABLE_DEPRECATED
};

/** Abstracts signal emission.
 * This template specialization implements an optimized emit()
 * function for the case that no accumulator is used and the
 * return type is @p void.
 */
template <>
struct signal_emit0<void, nil>
{
  typedef signal_emit0<void, nil> self_type;
  typedef void result_type;
  typedef slot<void()> slot_type;
  typedef signal_impl::const_iterator_type iterator_type;
  typedef void (*call_type)(slot_rep*);

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   */
  static result_type emit(signal_impl* impl)
    {
      if (!impl || impl->slots_.empty()) return;
      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      for (const auto& slot : slots)
        {
          if (slot.empty() || slot.blocked())
            continue;
          (sigc::internal::function_pointer_cast<call_type>(slot.rep_->call_))(slot.rep_);
        }
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl)
    {
      if (!impl || impl->slots_.empty()) return;
      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
      typedef std::reverse_iterator<signal_impl::iterator_type> reverse_iterator_type;
#else
      typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
                                     slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
#endif
      for (auto it = reverse_iterator_type(slots.end()); it != reverse_iterator_type(slots.begin()); ++it)
        {
          if (it->empty() || it->blocked())
            continue;
          (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_);
        }
    }
#endif // SIGCXX_DISABLE_DEPRECATED
};

/** Abstracts signal emission.
 * This template implements the emit() function of signal1.
 * Template specializations are available to optimize signal
 * emission when no accumulator is used, for example when the template
 * argument @e T_accumulator is @p nil.
 */
template <class T_return, class T_arg1, class T_accumulator>
struct signal_emit1
{
  typedef signal_emit1<T_return, T_arg1, T_accumulator> self_type;
  typedef typename T_accumulator::result_type result_type;
  typedef slot<T_return(T_arg1)> slot_type;
  typedef internal::slot_iterator_buf<self_type, T_return> slot_iterator_buf_type;
  typedef internal::slot_reverse_iterator_buf<self_type, T_return> slot_reverse_iterator_buf_type;
  typedef signal_impl::const_iterator_type iterator_type;

  /** Instantiates the class.
   * The parameters are stored in member variables. operator()() passes
   * the values on to some slot.
   */
  signal_emit1(type_trait_take_t<T_arg1> _A_a1) 
    : _A_a1_(_A_a1) {}


  /** Invokes a slot using the buffered parameter values.
   * @param _A_slot Some slot to invoke.
   * @return The slot's return value.
   */
  T_return operator()(const slot_type& _A_slot) const
    { return (sigc::internal::function_pointer_cast<typename slot_type::call_type>(_A_slot.rep_->call_))(_A_slot.rep_, _A_a1_); }

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are buffered in a temporary instance of signal_emit1.

   * @param _A_a1 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations as processed by the accumulator.
   */
  static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1)
    {
      T_accumulator accumulator;

      if (!impl)
        return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());

      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      self_type self (_A_a1);
      return accumulator(slot_iterator_buf_type(slots.begin(), &self),
                         slot_iterator_buf_type(slots.end(), &self));
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are buffered in a temporary instance of signal_emit1.

   * @param _A_a1 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations as processed by the accumulator.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1)
    {
      T_accumulator accumulator;

      if (!impl)
        return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());

      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      self_type self (_A_a1);
      return accumulator(slot_reverse_iterator_buf_type(slots.end(), &self),
                         slot_reverse_iterator_buf_type(slots.begin(), &self));
    }
#endif // SIGCXX_DISABLE_DEPRECATED

  
  type_trait_take_t<T_arg1> _A_a1_;
};

/** Abstracts signal emission.
 * This template specialization implements an optimized emit()
 * function for the case that no accumulator is used.
 */
template <class T_return, class T_arg1>
struct signal_emit1<T_return, T_arg1, nil>
{
  typedef signal_emit1<T_return, T_arg1, nil > self_type;
  typedef T_return result_type;
  typedef slot<T_return(T_arg1)> slot_type;
  typedef signal_impl::const_iterator_type iterator_type;
  typedef typename slot_type::call_type call_type;

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are passed directly on to the slots.
   * The return value of the last slot invoked is returned.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @return The return value of the last slot invoked.
   */
  static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1)
    {
      if (!impl || impl->slots_.empty())
        return T_return();
        
      signal_exec exec(impl);
      T_return r_ = T_return(); 
      
      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
      { 
        temp_slot_list slots(impl->slots_);
        auto it = slots.begin();
        for (; it != slots.end(); ++it)
          if (!it->empty() && !it->blocked()) break;
          
        if (it == slots.end())
          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
  
        r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
        for (++it; it != slots.end(); ++it)
          {
            if (it->empty() || it->blocked())
              continue;
            r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
          }
      }
      
      return r_;
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are passed directly on to the slots.
   * The return value of the last slot invoked is returned.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @return The return value of the last slot invoked.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1)
    {
      if (!impl || impl->slots_.empty())
        return T_return();
        
      signal_exec exec(impl);
      T_return r_ = T_return(); 
      
      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
      { 
#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
        typedef std::reverse_iterator<signal_impl::iterator_type> reverse_iterator_type;
#else
        typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
                                       slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
#endif

        temp_slot_list slots(impl->slots_);
        reverse_iterator_type it(slots.end());
        for (; it != reverse_iterator_type(slots.begin()); ++it)
          if (!it->empty() && !it->blocked()) break;
          
        if (it == reverse_iterator_type(slots.begin()))
          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
  
        r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
        for (++it; it != reverse_iterator_type(slots.begin()); ++it)
          {
            if (it->empty() || it->blocked())
              continue;
            r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
          }
      }
      
      return r_;
    }
#endif // SIGCXX_DISABLE_DEPRECATED
};

/** Abstracts signal emission.
 * This template specialization implements an optimized emit()
 * function for the case that no accumulator is used and the
 * return type is @p void.
 */
template <class T_arg1>
struct signal_emit1<void, T_arg1, nil>
{
  typedef signal_emit1<void, T_arg1, nil> self_type;
  typedef void result_type;
  typedef slot<void(T_arg1)> slot_type;
  typedef signal_impl::const_iterator_type iterator_type;
  typedef typename slot_type::call_type call_type;

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are passed directly on to the slots.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   */
  static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1)
    {
      if (!impl || impl->slots_.empty()) return;
      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      for (const auto& slot : slots)
        {
          if (slot.empty() || slot.blocked())
            continue;
          (sigc::internal::function_pointer_cast<call_type>(slot.rep_->call_))(slot.rep_, _A_a1);
        }
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are passed directly on to the slots.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1)
    {
      if (!impl || impl->slots_.empty()) return;
      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
      typedef std::reverse_iterator<signal_impl::iterator_type> reverse_iterator_type;
#else
      typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
                                     slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
#endif
      for (auto it = reverse_iterator_type(slots.end()); it != reverse_iterator_type(slots.begin()); ++it)
        {
          if (it->empty() || it->blocked())
            continue;
          (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
        }
    }
#endif // SIGCXX_DISABLE_DEPRECATED
};

/** Abstracts signal emission.
 * This template implements the emit() function of signal2.
 * Template specializations are available to optimize signal
 * emission when no accumulator is used, for example when the template
 * argument @e T_accumulator is @p nil.
 */
template <class T_return, class T_arg1, class T_arg2, class T_accumulator>
struct signal_emit2
{
  typedef signal_emit2<T_return, T_arg1, T_arg2, T_accumulator> self_type;
  typedef typename T_accumulator::result_type result_type;
  typedef slot<T_return(T_arg1, T_arg2)> slot_type;
  typedef internal::slot_iterator_buf<self_type, T_return> slot_iterator_buf_type;
  typedef internal::slot_reverse_iterator_buf<self_type, T_return> slot_reverse_iterator_buf_type;
  typedef signal_impl::const_iterator_type iterator_type;

  /** Instantiates the class.
   * The parameters are stored in member variables. operator()() passes
   * the values on to some slot.
   */
  signal_emit2(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) 
    : _A_a1_(_A_a1), _A_a2_(_A_a2) {}


  /** Invokes a slot using the buffered parameter values.
   * @param _A_slot Some slot to invoke.
   * @return The slot's return value.
   */
  T_return operator()(const slot_type& _A_slot) const
    { return (sigc::internal::function_pointer_cast<typename slot_type::call_type>(_A_slot.rep_->call_))(_A_slot.rep_, _A_a1_, _A_a2_); }

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are buffered in a temporary instance of signal_emit2.

   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations as processed by the accumulator.
   */
  static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2)
    {
      T_accumulator accumulator;

      if (!impl)
        return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());

      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      self_type self (_A_a1, _A_a2);
      return accumulator(slot_iterator_buf_type(slots.begin(), &self),
                         slot_iterator_buf_type(slots.end(), &self));
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are buffered in a temporary instance of signal_emit2.

   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations as processed by the accumulator.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2)
    {
      T_accumulator accumulator;

      if (!impl)
        return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());

      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      self_type self (_A_a1, _A_a2);
      return accumulator(slot_reverse_iterator_buf_type(slots.end(), &self),
                         slot_reverse_iterator_buf_type(slots.begin(), &self));
    }
#endif // SIGCXX_DISABLE_DEPRECATED

  
  type_trait_take_t<T_arg1> _A_a1_;
  type_trait_take_t<T_arg2> _A_a2_;
};

/** Abstracts signal emission.
 * This template specialization implements an optimized emit()
 * function for the case that no accumulator is used.
 */
template <class T_return, class T_arg1, class T_arg2>
struct signal_emit2<T_return, T_arg1, T_arg2, nil>
{
  typedef signal_emit2<T_return, T_arg1, T_arg2, nil > self_type;
  typedef T_return result_type;
  typedef slot<T_return(T_arg1, T_arg2)> slot_type;
  typedef signal_impl::const_iterator_type iterator_type;
  typedef typename slot_type::call_type call_type;

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are passed directly on to the slots.
   * The return value of the last slot invoked is returned.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @return The return value of the last slot invoked.
   */
  static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2)
    {
      if (!impl || impl->slots_.empty())
        return T_return();
        
      signal_exec exec(impl);
      T_return r_ = T_return(); 
      
      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
      { 
        temp_slot_list slots(impl->slots_);
        auto it = slots.begin();
        for (; it != slots.end(); ++it)
          if (!it->empty() && !it->blocked()) break;
          
        if (it == slots.end())
          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
  
        r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2);
        for (++it; it != slots.end(); ++it)
          {
            if (it->empty() || it->blocked())
              continue;
            r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2);
          }
      }
      
      return r_;
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are passed directly on to the slots.
   * The return value of the last slot invoked is returned.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @return The return value of the last slot invoked.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2)
    {
      if (!impl || impl->slots_.empty())
        return T_return();
        
      signal_exec exec(impl);
      T_return r_ = T_return(); 
      
      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
      { 
#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
        typedef std::reverse_iterator<signal_impl::iterator_type> reverse_iterator_type;
#else
        typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
                                       slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
#endif

        temp_slot_list slots(impl->slots_);
        reverse_iterator_type it(slots.end());
        for (; it != reverse_iterator_type(slots.begin()); ++it)
          if (!it->empty() && !it->blocked()) break;
          
        if (it == reverse_iterator_type(slots.begin()))
          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
  
        r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2);
        for (++it; it != reverse_iterator_type(slots.begin()); ++it)
          {
            if (it->empty() || it->blocked())
              continue;
            r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2);
          }
      }
      
      return r_;
    }
#endif // SIGCXX_DISABLE_DEPRECATED
};

/** Abstracts signal emission.
 * This template specialization implements an optimized emit()
 * function for the case that no accumulator is used and the
 * return type is @p void.
 */
template <class T_arg1, class T_arg2>
struct signal_emit2<void, T_arg1, T_arg2, nil>
{
  typedef signal_emit2<void, T_arg1, T_arg2, nil> self_type;
  typedef void result_type;
  typedef slot<void(T_arg1, T_arg2)> slot_type;
  typedef signal_impl::const_iterator_type iterator_type;
  typedef typename slot_type::call_type call_type;

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are passed directly on to the slots.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   */
  static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2)
    {
      if (!impl || impl->slots_.empty()) return;
      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      for (const auto& slot : slots)
        {
          if (slot.empty() || slot.blocked())
            continue;
          (sigc::internal::function_pointer_cast<call_type>(slot.rep_->call_))(slot.rep_, _A_a1, _A_a2);
        }
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are passed directly on to the slots.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2)
    {
      if (!impl || impl->slots_.empty()) return;
      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
      typedef std::reverse_iterator<signal_impl::iterator_type> reverse_iterator_type;
#else
      typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
                                     slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
#endif
      for (auto it = reverse_iterator_type(slots.end()); it != reverse_iterator_type(slots.begin()); ++it)
        {
          if (it->empty() || it->blocked())
            continue;
          (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2);
        }
    }
#endif // SIGCXX_DISABLE_DEPRECATED
};

/** Abstracts signal emission.
 * This template implements the emit() function of signal3.
 * Template specializations are available to optimize signal
 * emission when no accumulator is used, for example when the template
 * argument @e T_accumulator is @p nil.
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_accumulator>
struct signal_emit3
{
  typedef signal_emit3<T_return, T_arg1, T_arg2, T_arg3, T_accumulator> self_type;
  typedef typename T_accumulator::result_type result_type;
  typedef slot<T_return(T_arg1, T_arg2, T_arg3)> slot_type;
  typedef internal::slot_iterator_buf<self_type, T_return> slot_iterator_buf_type;
  typedef internal::slot_reverse_iterator_buf<self_type, T_return> slot_reverse_iterator_buf_type;
  typedef signal_impl::const_iterator_type iterator_type;

  /** Instantiates the class.
   * The parameters are stored in member variables. operator()() passes
   * the values on to some slot.
   */
  signal_emit3(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) 
    : _A_a1_(_A_a1), _A_a2_(_A_a2), _A_a3_(_A_a3) {}


  /** Invokes a slot using the buffered parameter values.
   * @param _A_slot Some slot to invoke.
   * @return The slot's return value.
   */
  T_return operator()(const slot_type& _A_slot) const
    { return (sigc::internal::function_pointer_cast<typename slot_type::call_type>(_A_slot.rep_->call_))(_A_slot.rep_, _A_a1_, _A_a2_, _A_a3_); }

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are buffered in a temporary instance of signal_emit3.

   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations as processed by the accumulator.
   */
  static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3)
    {
      T_accumulator accumulator;

      if (!impl)
        return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());

      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      self_type self (_A_a1, _A_a2, _A_a3);
      return accumulator(slot_iterator_buf_type(slots.begin(), &self),
                         slot_iterator_buf_type(slots.end(), &self));
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are buffered in a temporary instance of signal_emit3.

   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations as processed by the accumulator.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3)
    {
      T_accumulator accumulator;

      if (!impl)
        return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());

      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      self_type self (_A_a1, _A_a2, _A_a3);
      return accumulator(slot_reverse_iterator_buf_type(slots.end(), &self),
                         slot_reverse_iterator_buf_type(slots.begin(), &self));
    }
#endif // SIGCXX_DISABLE_DEPRECATED

  
  type_trait_take_t<T_arg1> _A_a1_;
  type_trait_take_t<T_arg2> _A_a2_;
  type_trait_take_t<T_arg3> _A_a3_;
};

/** Abstracts signal emission.
 * This template specialization implements an optimized emit()
 * function for the case that no accumulator is used.
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3>
struct signal_emit3<T_return, T_arg1, T_arg2, T_arg3, nil>
{
  typedef signal_emit3<T_return, T_arg1, T_arg2, T_arg3, nil > self_type;
  typedef T_return result_type;
  typedef slot<T_return(T_arg1, T_arg2, T_arg3)> slot_type;
  typedef signal_impl::const_iterator_type iterator_type;
  typedef typename slot_type::call_type call_type;

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are passed directly on to the slots.
   * The return value of the last slot invoked is returned.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @return The return value of the last slot invoked.
   */
  static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3)
    {
      if (!impl || impl->slots_.empty())
        return T_return();
        
      signal_exec exec(impl);
      T_return r_ = T_return(); 
      
      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
      { 
        temp_slot_list slots(impl->slots_);
        auto it = slots.begin();
        for (; it != slots.end(); ++it)
          if (!it->empty() && !it->blocked()) break;
          
        if (it == slots.end())
          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
  
        r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3);
        for (++it; it != slots.end(); ++it)
          {
            if (it->empty() || it->blocked())
              continue;
            r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3);
          }
      }
      
      return r_;
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are passed directly on to the slots.
   * The return value of the last slot invoked is returned.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @return The return value of the last slot invoked.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3)
    {
      if (!impl || impl->slots_.empty())
        return T_return();
        
      signal_exec exec(impl);
      T_return r_ = T_return(); 
      
      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
      { 
#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
        typedef std::reverse_iterator<signal_impl::iterator_type> reverse_iterator_type;
#else
        typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
                                       slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
#endif

        temp_slot_list slots(impl->slots_);
        reverse_iterator_type it(slots.end());
        for (; it != reverse_iterator_type(slots.begin()); ++it)
          if (!it->empty() && !it->blocked()) break;
          
        if (it == reverse_iterator_type(slots.begin()))
          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
  
        r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3);
        for (++it; it != reverse_iterator_type(slots.begin()); ++it)
          {
            if (it->empty() || it->blocked())
              continue;
            r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3);
          }
      }
      
      return r_;
    }
#endif // SIGCXX_DISABLE_DEPRECATED
};

/** Abstracts signal emission.
 * This template specialization implements an optimized emit()
 * function for the case that no accumulator is used and the
 * return type is @p void.
 */
template <class T_arg1, class T_arg2, class T_arg3>
struct signal_emit3<void, T_arg1, T_arg2, T_arg3, nil>
{
  typedef signal_emit3<void, T_arg1, T_arg2, T_arg3, nil> self_type;
  typedef void result_type;
  typedef slot<void(T_arg1, T_arg2, T_arg3)> slot_type;
  typedef signal_impl::const_iterator_type iterator_type;
  typedef typename slot_type::call_type call_type;

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are passed directly on to the slots.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   */
  static result_type emit(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3)
    {
      if (!impl || impl->slots_.empty()) return;
      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      for (const auto& slot : slots)
        {
          if (slot.empty() || slot.blocked())
            continue;
          (sigc::internal::function_pointer_cast<call_type>(slot.rep_->call_))(slot.rep_, _A_a1, _A_a2, _A_a3);
        }
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are passed directly on to the slots.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3)
    {
      if (!impl || impl->slots_.empty()) return;
      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
      typedef std::reverse_iterator<signal_impl::iterator_type> reverse_iterator_type;
#else
      typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
                                     slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
#endif
      for (auto it = reverse_iterator_type(slots.end()); it != reverse_iterator_type(slots.begin()); ++it)
        {
          if (it->empty() || it->blocked())
            continue;
          (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3);
        }
    }
#endif // SIGCXX_DISABLE_DEPRECATED
};

/** Abstracts signal emission.
 * This template implements the emit() function of signal4.
 * Template specializations are available to optimize signal
 * emission when no accumulator is used, for example when the template
 * argument @e T_accumulator is @p nil.
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_accumulator>
struct signal_emit4
{
  typedef signal_emit4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator> self_type;
  typedef typename T_accumulator::result_type result_type;
  typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4)> slot_type;
  typedef internal::slot_iterator_buf<self_type, T_return> slot_iterator_buf_type;
  typedef internal::slot_reverse_iterator_buf<self_type, T_return> slot_reverse_iterator_buf_type;
  typedef signal_impl::const_iterator_type iterator_type;

  /** Instantiates the class.
   * The parameters are stored in member variables. operator()() passes
   * the values on to some slot.
   */
  signal_emit4(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) 
    : _A_a1_(_A_a1), _A_a2_(_A_a2), _A_a3_(_A_a3), _A_a4_(_A_a4) {}


  /** Invokes a slot using the buffered parameter values.
   * @param _A_slot Some slot to invoke.
   * @return The slot's return value.
   */
  T_return operator()(const slot_type& _A_slot) const
    { return (sigc::internal::function_pointer_cast<typename slot_type::call_type>(_A_slot.rep_->call_))(_A_slot.rep_, _A_a1_, _A_a2_, _A_a3_, _A_a4_); }

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are buffered in a temporary instance of signal_emit4.

   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations as processed by the accumulator.
   */
  static result_type emit(signal_impl* impl, 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)
    {
      T_accumulator accumulator;

      if (!impl)
        return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());

      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      self_type self (_A_a1, _A_a2, _A_a3, _A_a4);
      return accumulator(slot_iterator_buf_type(slots.begin(), &self),
                         slot_iterator_buf_type(slots.end(), &self));
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are buffered in a temporary instance of signal_emit4.

   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations as processed by the accumulator.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, 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)
    {
      T_accumulator accumulator;

      if (!impl)
        return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());

      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      self_type self (_A_a1, _A_a2, _A_a3, _A_a4);
      return accumulator(slot_reverse_iterator_buf_type(slots.end(), &self),
                         slot_reverse_iterator_buf_type(slots.begin(), &self));
    }
#endif // SIGCXX_DISABLE_DEPRECATED

  
  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_;
};

/** Abstracts signal emission.
 * This template specialization implements an optimized emit()
 * function for the case that no accumulator is used.
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
struct signal_emit4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>
{
  typedef signal_emit4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil > self_type;
  typedef T_return result_type;
  typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4)> slot_type;
  typedef signal_impl::const_iterator_type iterator_type;
  typedef typename slot_type::call_type call_type;

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are passed directly on to the slots.
   * The return value of the last slot invoked is returned.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @return The return value of the last slot invoked.
   */
  static result_type emit(signal_impl* impl, 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)
    {
      if (!impl || impl->slots_.empty())
        return T_return();
        
      signal_exec exec(impl);
      T_return r_ = T_return(); 
      
      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
      { 
        temp_slot_list slots(impl->slots_);
        auto it = slots.begin();
        for (; it != slots.end(); ++it)
          if (!it->empty() && !it->blocked()) break;
          
        if (it == slots.end())
          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
  
        r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4);
        for (++it; it != slots.end(); ++it)
          {
            if (it->empty() || it->blocked())
              continue;
            r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4);
          }
      }
      
      return r_;
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are passed directly on to the slots.
   * The return value of the last slot invoked is returned.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @return The return value of the last slot invoked.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, 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)
    {
      if (!impl || impl->slots_.empty())
        return T_return();
        
      signal_exec exec(impl);
      T_return r_ = T_return(); 
      
      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
      { 
#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
        typedef std::reverse_iterator<signal_impl::iterator_type> reverse_iterator_type;
#else
        typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
                                       slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
#endif

        temp_slot_list slots(impl->slots_);
        reverse_iterator_type it(slots.end());
        for (; it != reverse_iterator_type(slots.begin()); ++it)
          if (!it->empty() && !it->blocked()) break;
          
        if (it == reverse_iterator_type(slots.begin()))
          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
  
        r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4);
        for (++it; it != reverse_iterator_type(slots.begin()); ++it)
          {
            if (it->empty() || it->blocked())
              continue;
            r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4);
          }
      }
      
      return r_;
    }
#endif // SIGCXX_DISABLE_DEPRECATED
};

/** Abstracts signal emission.
 * This template specialization implements an optimized emit()
 * function for the case that no accumulator is used and the
 * return type is @p void.
 */
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
struct signal_emit4<void, T_arg1, T_arg2, T_arg3, T_arg4, nil>
{
  typedef signal_emit4<void, T_arg1, T_arg2, T_arg3, T_arg4, nil> self_type;
  typedef void result_type;
  typedef slot<void(T_arg1, T_arg2, T_arg3, T_arg4)> slot_type;
  typedef signal_impl::const_iterator_type iterator_type;
  typedef typename slot_type::call_type call_type;

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are passed directly on to the slots.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   */
  static result_type emit(signal_impl* impl, 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)
    {
      if (!impl || impl->slots_.empty()) return;
      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      for (const auto& slot : slots)
        {
          if (slot.empty() || slot.blocked())
            continue;
          (sigc::internal::function_pointer_cast<call_type>(slot.rep_->call_))(slot.rep_, _A_a1, _A_a2, _A_a3, _A_a4);
        }
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are passed directly on to the slots.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, 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)
    {
      if (!impl || impl->slots_.empty()) return;
      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
      typedef std::reverse_iterator<signal_impl::iterator_type> reverse_iterator_type;
#else
      typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
                                     slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
#endif
      for (auto it = reverse_iterator_type(slots.end()); it != reverse_iterator_type(slots.begin()); ++it)
        {
          if (it->empty() || it->blocked())
            continue;
          (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4);
        }
    }
#endif // SIGCXX_DISABLE_DEPRECATED
};

/** Abstracts signal emission.
 * This template implements the emit() function of signal5.
 * Template specializations are available to optimize signal
 * emission when no accumulator is used, for example when the template
 * argument @e T_accumulator is @p nil.
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_accumulator>
struct signal_emit5
{
  typedef signal_emit5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator> self_type;
  typedef typename T_accumulator::result_type result_type;
  typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> slot_type;
  typedef internal::slot_iterator_buf<self_type, T_return> slot_iterator_buf_type;
  typedef internal::slot_reverse_iterator_buf<self_type, T_return> slot_reverse_iterator_buf_type;
  typedef signal_impl::const_iterator_type iterator_type;

  /** Instantiates the class.
   * The parameters are stored in member variables. operator()() passes
   * the values on to some slot.
   */
  signal_emit5(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) 
    : _A_a1_(_A_a1), _A_a2_(_A_a2), _A_a3_(_A_a3), _A_a4_(_A_a4), _A_a5_(_A_a5) {}


  /** Invokes a slot using the buffered parameter values.
   * @param _A_slot Some slot to invoke.
   * @return The slot's return value.
   */
  T_return operator()(const slot_type& _A_slot) const
    { return (sigc::internal::function_pointer_cast<typename slot_type::call_type>(_A_slot.rep_->call_))(_A_slot.rep_, _A_a1_, _A_a2_, _A_a3_, _A_a4_, _A_a5_); }

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are buffered in a temporary instance of signal_emit5.

   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations as processed by the accumulator.
   */
  static result_type emit(signal_impl* impl, 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)
    {
      T_accumulator accumulator;

      if (!impl)
        return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());

      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      self_type self (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
      return accumulator(slot_iterator_buf_type(slots.begin(), &self),
                         slot_iterator_buf_type(slots.end(), &self));
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are buffered in a temporary instance of signal_emit5.

   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations as processed by the accumulator.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, 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)
    {
      T_accumulator accumulator;

      if (!impl)
        return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());

      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      self_type self (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
      return accumulator(slot_reverse_iterator_buf_type(slots.end(), &self),
                         slot_reverse_iterator_buf_type(slots.begin(), &self));
    }
#endif // SIGCXX_DISABLE_DEPRECATED

  
  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_;
};

/** Abstracts signal emission.
 * This template specialization implements an optimized emit()
 * function for the case that no accumulator is used.
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
struct signal_emit5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>
{
  typedef signal_emit5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil > self_type;
  typedef T_return result_type;
  typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> slot_type;
  typedef signal_impl::const_iterator_type iterator_type;
  typedef typename slot_type::call_type call_type;

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are passed directly on to the slots.
   * The return value of the last slot invoked is returned.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @return The return value of the last slot invoked.
   */
  static result_type emit(signal_impl* impl, 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)
    {
      if (!impl || impl->slots_.empty())
        return T_return();
        
      signal_exec exec(impl);
      T_return r_ = T_return(); 
      
      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
      { 
        temp_slot_list slots(impl->slots_);
        auto it = slots.begin();
        for (; it != slots.end(); ++it)
          if (!it->empty() && !it->blocked()) break;
          
        if (it == slots.end())
          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
  
        r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
        for (++it; it != slots.end(); ++it)
          {
            if (it->empty() || it->blocked())
              continue;
            r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
          }
      }
      
      return r_;
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are passed directly on to the slots.
   * The return value of the last slot invoked is returned.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @return The return value of the last slot invoked.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, 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)
    {
      if (!impl || impl->slots_.empty())
        return T_return();
        
      signal_exec exec(impl);
      T_return r_ = T_return(); 
      
      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
      { 
#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
        typedef std::reverse_iterator<signal_impl::iterator_type> reverse_iterator_type;
#else
        typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
                                       slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
#endif

        temp_slot_list slots(impl->slots_);
        reverse_iterator_type it(slots.end());
        for (; it != reverse_iterator_type(slots.begin()); ++it)
          if (!it->empty() && !it->blocked()) break;
          
        if (it == reverse_iterator_type(slots.begin()))
          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
  
        r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
        for (++it; it != reverse_iterator_type(slots.begin()); ++it)
          {
            if (it->empty() || it->blocked())
              continue;
            r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
          }
      }
      
      return r_;
    }
#endif // SIGCXX_DISABLE_DEPRECATED
};

/** Abstracts signal emission.
 * This template specialization implements an optimized emit()
 * function for the case that no accumulator is used and the
 * return type is @p void.
 */
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
struct signal_emit5<void, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>
{
  typedef signal_emit5<void, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil> self_type;
  typedef void result_type;
  typedef slot<void(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)> slot_type;
  typedef signal_impl::const_iterator_type iterator_type;
  typedef typename slot_type::call_type call_type;

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are passed directly on to the slots.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   */
  static result_type emit(signal_impl* impl, 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)
    {
      if (!impl || impl->slots_.empty()) return;
      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      for (const auto& slot : slots)
        {
          if (slot.empty() || slot.blocked())
            continue;
          (sigc::internal::function_pointer_cast<call_type>(slot.rep_->call_))(slot.rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
        }
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are passed directly on to the slots.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, 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)
    {
      if (!impl || impl->slots_.empty()) return;
      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
      typedef std::reverse_iterator<signal_impl::iterator_type> reverse_iterator_type;
#else
      typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
                                     slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
#endif
      for (auto it = reverse_iterator_type(slots.end()); it != reverse_iterator_type(slots.begin()); ++it)
        {
          if (it->empty() || it->blocked())
            continue;
          (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5);
        }
    }
#endif // SIGCXX_DISABLE_DEPRECATED
};

/** Abstracts signal emission.
 * This template implements the emit() function of signal6.
 * Template specializations are available to optimize signal
 * emission when no accumulator is used, for example when the template
 * argument @e T_accumulator is @p nil.
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_accumulator>
struct signal_emit6
{
  typedef signal_emit6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator> self_type;
  typedef typename T_accumulator::result_type result_type;
  typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> slot_type;
  typedef internal::slot_iterator_buf<self_type, T_return> slot_iterator_buf_type;
  typedef internal::slot_reverse_iterator_buf<self_type, T_return> slot_reverse_iterator_buf_type;
  typedef signal_impl::const_iterator_type iterator_type;

  /** Instantiates the class.
   * The parameters are stored in member variables. operator()() passes
   * the values on to some slot.
   */
  signal_emit6(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) 
    : _A_a1_(_A_a1), _A_a2_(_A_a2), _A_a3_(_A_a3), _A_a4_(_A_a4), _A_a5_(_A_a5), _A_a6_(_A_a6) {}


  /** Invokes a slot using the buffered parameter values.
   * @param _A_slot Some slot to invoke.
   * @return The slot's return value.
   */
  T_return operator()(const slot_type& _A_slot) const
    { return (sigc::internal::function_pointer_cast<typename slot_type::call_type>(_A_slot.rep_->call_))(_A_slot.rep_, _A_a1_, _A_a2_, _A_a3_, _A_a4_, _A_a5_, _A_a6_); }

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are buffered in a temporary instance of signal_emit6.

   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @param _A_a6 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations as processed by the accumulator.
   */
  static result_type emit(signal_impl* impl, 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)
    {
      T_accumulator accumulator;

      if (!impl)
        return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());

      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      self_type self (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
      return accumulator(slot_iterator_buf_type(slots.begin(), &self),
                         slot_iterator_buf_type(slots.end(), &self));
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are buffered in a temporary instance of signal_emit6.

   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @param _A_a6 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations as processed by the accumulator.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, 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)
    {
      T_accumulator accumulator;

      if (!impl)
        return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());

      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      self_type self (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
      return accumulator(slot_reverse_iterator_buf_type(slots.end(), &self),
                         slot_reverse_iterator_buf_type(slots.begin(), &self));
    }
#endif // SIGCXX_DISABLE_DEPRECATED

  
  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_;
};

/** Abstracts signal emission.
 * This template specialization implements an optimized emit()
 * function for the case that no accumulator is used.
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
struct signal_emit6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>
{
  typedef signal_emit6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil > self_type;
  typedef T_return result_type;
  typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> slot_type;
  typedef signal_impl::const_iterator_type iterator_type;
  typedef typename slot_type::call_type call_type;

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are passed directly on to the slots.
   * The return value of the last slot invoked is returned.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @param _A_a6 Argument to be passed on to the slots.
   * @return The return value of the last slot invoked.
   */
  static result_type emit(signal_impl* impl, 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)
    {
      if (!impl || impl->slots_.empty())
        return T_return();
        
      signal_exec exec(impl);
      T_return r_ = T_return(); 
      
      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
      { 
        temp_slot_list slots(impl->slots_);
        auto it = slots.begin();
        for (; it != slots.end(); ++it)
          if (!it->empty() && !it->blocked()) break;
          
        if (it == slots.end())
          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
  
        r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
        for (++it; it != slots.end(); ++it)
          {
            if (it->empty() || it->blocked())
              continue;
            r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
          }
      }
      
      return r_;
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are passed directly on to the slots.
   * The return value of the last slot invoked is returned.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @param _A_a6 Argument to be passed on to the slots.
   * @return The return value of the last slot invoked.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, 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)
    {
      if (!impl || impl->slots_.empty())
        return T_return();
        
      signal_exec exec(impl);
      T_return r_ = T_return(); 
      
      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
      { 
#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
        typedef std::reverse_iterator<signal_impl::iterator_type> reverse_iterator_type;
#else
        typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
                                       slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
#endif

        temp_slot_list slots(impl->slots_);
        reverse_iterator_type it(slots.end());
        for (; it != reverse_iterator_type(slots.begin()); ++it)
          if (!it->empty() && !it->blocked()) break;
          
        if (it == reverse_iterator_type(slots.begin()))
          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
  
        r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
        for (++it; it != reverse_iterator_type(slots.begin()); ++it)
          {
            if (it->empty() || it->blocked())
              continue;
            r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
          }
      }
      
      return r_;
    }
#endif // SIGCXX_DISABLE_DEPRECATED
};

/** Abstracts signal emission.
 * This template specialization implements an optimized emit()
 * function for the case that no accumulator is used and the
 * return type is @p void.
 */
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
struct signal_emit6<void, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>
{
  typedef signal_emit6<void, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil> self_type;
  typedef void result_type;
  typedef slot<void(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)> slot_type;
  typedef signal_impl::const_iterator_type iterator_type;
  typedef typename slot_type::call_type call_type;

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are passed directly on to the slots.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @param _A_a6 Argument to be passed on to the slots.
   */
  static result_type emit(signal_impl* impl, 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)
    {
      if (!impl || impl->slots_.empty()) return;
      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      for (const auto& slot : slots)
        {
          if (slot.empty() || slot.blocked())
            continue;
          (sigc::internal::function_pointer_cast<call_type>(slot.rep_->call_))(slot.rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
        }
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are passed directly on to the slots.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @param _A_a6 Argument to be passed on to the slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, 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)
    {
      if (!impl || impl->slots_.empty()) return;
      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
      typedef std::reverse_iterator<signal_impl::iterator_type> reverse_iterator_type;
#else
      typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
                                     slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
#endif
      for (auto it = reverse_iterator_type(slots.end()); it != reverse_iterator_type(slots.begin()); ++it)
        {
          if (it->empty() || it->blocked())
            continue;
          (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6);
        }
    }
#endif // SIGCXX_DISABLE_DEPRECATED
};

/** Abstracts signal emission.
 * This template implements the emit() function of signal7.
 * Template specializations are available to optimize signal
 * emission when no accumulator is used, for example when the template
 * argument @e T_accumulator is @p nil.
 */
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 T_accumulator>
struct signal_emit7
{
  typedef signal_emit7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator> self_type;
  typedef typename T_accumulator::result_type result_type;
  typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> slot_type;
  typedef internal::slot_iterator_buf<self_type, T_return> slot_iterator_buf_type;
  typedef internal::slot_reverse_iterator_buf<self_type, T_return> slot_reverse_iterator_buf_type;
  typedef signal_impl::const_iterator_type iterator_type;

  /** Instantiates the class.
   * The parameters are stored in member variables. operator()() passes
   * the values on to some slot.
   */
  signal_emit7(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) 
    : _A_a1_(_A_a1), _A_a2_(_A_a2), _A_a3_(_A_a3), _A_a4_(_A_a4), _A_a5_(_A_a5), _A_a6_(_A_a6), _A_a7_(_A_a7) {}


  /** Invokes a slot using the buffered parameter values.
   * @param _A_slot Some slot to invoke.
   * @return The slot's return value.
   */
  T_return operator()(const slot_type& _A_slot) const
    { return (sigc::internal::function_pointer_cast<typename slot_type::call_type>(_A_slot.rep_->call_))(_A_slot.rep_, _A_a1_, _A_a2_, _A_a3_, _A_a4_, _A_a5_, _A_a6_, _A_a7_); }

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are buffered in a temporary instance of signal_emit7.

   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @param _A_a6 Argument to be passed on to the slots.
   * @param _A_a7 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations as processed by the accumulator.
   */
  static result_type emit(signal_impl* impl, 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)
    {
      T_accumulator accumulator;

      if (!impl)
        return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());

      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      self_type self (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
      return accumulator(slot_iterator_buf_type(slots.begin(), &self),
                         slot_iterator_buf_type(slots.end(), &self));
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are buffered in a temporary instance of signal_emit7.

   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @param _A_a6 Argument to be passed on to the slots.
   * @param _A_a7 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations as processed by the accumulator.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, 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)
    {
      T_accumulator accumulator;

      if (!impl)
        return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());

      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      self_type self (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
      return accumulator(slot_reverse_iterator_buf_type(slots.end(), &self),
                         slot_reverse_iterator_buf_type(slots.begin(), &self));
    }
#endif // SIGCXX_DISABLE_DEPRECATED

  
  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_;
};

/** Abstracts signal emission.
 * This template specialization implements an optimized emit()
 * function for the case that no accumulator is used.
 */
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>
struct signal_emit7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>
{
  typedef signal_emit7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil > self_type;
  typedef T_return result_type;
  typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> slot_type;
  typedef signal_impl::const_iterator_type iterator_type;
  typedef typename slot_type::call_type call_type;

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are passed directly on to the slots.
   * The return value of the last slot invoked is returned.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @param _A_a6 Argument to be passed on to the slots.
   * @param _A_a7 Argument to be passed on to the slots.
   * @return The return value of the last slot invoked.
   */
  static result_type emit(signal_impl* impl, 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)
    {
      if (!impl || impl->slots_.empty())
        return T_return();
        
      signal_exec exec(impl);
      T_return r_ = T_return(); 
      
      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
      { 
        temp_slot_list slots(impl->slots_);
        auto it = slots.begin();
        for (; it != slots.end(); ++it)
          if (!it->empty() && !it->blocked()) break;
          
        if (it == slots.end())
          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
  
        r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
        for (++it; it != slots.end(); ++it)
          {
            if (it->empty() || it->blocked())
              continue;
            r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
          }
      }
      
      return r_;
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are passed directly on to the slots.
   * The return value of the last slot invoked is returned.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @param _A_a6 Argument to be passed on to the slots.
   * @param _A_a7 Argument to be passed on to the slots.
   * @return The return value of the last slot invoked.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, 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)
    {
      if (!impl || impl->slots_.empty())
        return T_return();
        
      signal_exec exec(impl);
      T_return r_ = T_return(); 
      
      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
      { 
#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
        typedef std::reverse_iterator<signal_impl::iterator_type> reverse_iterator_type;
#else
        typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
                                       slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
#endif

        temp_slot_list slots(impl->slots_);
        reverse_iterator_type it(slots.end());
        for (; it != reverse_iterator_type(slots.begin()); ++it)
          if (!it->empty() && !it->blocked()) break;
          
        if (it == reverse_iterator_type(slots.begin()))
          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
  
        r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
        for (++it; it != reverse_iterator_type(slots.begin()); ++it)
          {
            if (it->empty() || it->blocked())
              continue;
            r_ = (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
          }
      }
      
      return r_;
    }
#endif // SIGCXX_DISABLE_DEPRECATED
};

/** Abstracts signal emission.
 * This template specialization implements an optimized emit()
 * function for the case that no accumulator is used and the
 * return type is @p void.
 */
template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
struct signal_emit7<void, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>
{
  typedef signal_emit7<void, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil> self_type;
  typedef void result_type;
  typedef slot<void(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)> slot_type;
  typedef signal_impl::const_iterator_type iterator_type;
  typedef typename slot_type::call_type call_type;

  /** Executes a list of slots using an accumulator of type @e T_accumulator.
   * The arguments are passed directly on to the slots.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @param _A_a6 Argument to be passed on to the slots.
   * @param _A_a7 Argument to be passed on to the slots.
   */
  static result_type emit(signal_impl* impl, 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)
    {
      if (!impl || impl->slots_.empty()) return;
      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

      for (const auto& slot : slots)
        {
          if (slot.empty() || slot.blocked())
            continue;
          (sigc::internal::function_pointer_cast<call_type>(slot.rep_->call_))(slot.rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
        }
    }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.
   * The arguments are passed directly on to the slots.
   * @param first An iterator pointing to the first slot in the list.
   * @param last An iterator pointing to the last slot in the list.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @param _A_a6 Argument to be passed on to the slots.
   * @param _A_a7 Argument to be passed on to the slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  static result_type emit_reverse(signal_impl* impl, 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)
    {
      if (!impl || impl->slots_.empty()) return;
      signal_exec exec(impl);
      temp_slot_list slots(impl->slots_);

#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
      typedef std::reverse_iterator<signal_impl::iterator_type> reverse_iterator_type;
#else
      typedef std::reverse_iterator<signal_impl::iterator_type, std::random_access_iterator_tag,
                                     slot_base, slot_base&, slot_base*, std::ptrdiff_t> reverse_iterator_type;
#endif
      for (auto it = reverse_iterator_type(slots.end()); it != reverse_iterator_type(slots.begin()); ++it)
        {
          if (it->empty() || it->blocked())
            continue;
          (sigc::internal::function_pointer_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7);
        }
    }
#endif // SIGCXX_DISABLE_DEPRECATED
};


} /* namespace internal */

/** Signal declaration.
 * signal0 can be used to connect() slots that are invoked
 * during subsequent calls to emit(). Any functor or slot
 * can be passed into connect(). It is converted into a slot
 * implicitly.
 *
 * If you want to connect one signal to another, use make_slot()
 * to retrieve a functor that emits the signal when invoked.
 *
 * Be careful if you directly pass one signal into the connect()
 * method of another: a shallow copy of the signal is made and
 * the signal's slots are not disconnected until both the signal
 * and its clone are destroyed, which is probably not what you want.
 *
 * The following template arguments are used:
 * - @e T_return The desired return type for the emit() function (may be overridden by the accumulator).
 * - @e T_accumulator The accumulator type used for emission. The default
 * @p nil means that no accumulator should be used, for example if signal
 * emission returns the return value of the last slot invoked.
 *
 * You should use the more convenient unnumbered sigc::signal template.
 *
 * @ingroup signal
 */
template <class T_return, class T_accumulator=nil>
class signal0
  : public signal_base
{
public:
  typedef internal::signal_emit0<T_return, T_accumulator> emitter_type;
  typedef typename emitter_type::result_type         result_type;
  typedef slot<T_return()>    slot_type;
  typedef slot_list<slot_type>                       slot_list_type;
  typedef typename slot_list_type::iterator               iterator;
  typedef typename slot_list_type::const_iterator         const_iterator;
  typedef typename slot_list_type::reverse_iterator       reverse_iterator;
  typedef typename slot_list_type::const_reverse_iterator const_reverse_iterator;

  /** Add a slot to the list of slots.
   * Any functor or slot may be passed into connect().
   * It will be converted into a slot implicitly.
   * The returned iterator may be stored for disconnection
   * of the slot at some later point. It stays valid until
   * the slot is removed from the list of slots. The iterator
   * can also be implicitly converted into a sigc::connection object
   * that may be used safely beyond the life time of the slot.
   *
   * std::function<> and C++11 lambda expressions are functors.
   * These are examples of functors that can be connected to a signal.
   *
   * %std::bind() creates a functor, but this functor typically has an
   * %operator()() which is a variadic template.
   * Our functor_trait can't deduce the result type
   * of such a functor. If you first assign the return value of %std::bind()
   * to a std::function, you can connect the std::function to a signal.
   *
   * @param slot_ The slot to add to the list of slots.
   * @return An iterator pointing to the new slot in the list.
   */
  iterator connect(const slot_type& slot_)
    { return iterator(signal_base::connect(static_cast<const slot_base&>(slot_))); }

  /** Add a slot to the list of slots.
   * @see connect(const slot_type& slot_).
   *
   * @newin{2,8}
   */
  iterator connect(slot_type&& slot_)
    { return iterator(signal_base::connect(std::move(static_cast<slot_base&>(slot_)))); }

  /** Triggers the emission of the signal.
   * During signal emission all slots that have been connected
   * to the signal are invoked unless they are manually set into
   * a blocking state. The parameters are passed on to the slots.
   * If @e T_accumulated is not @p nil, an accumulator of this type
   * is used to process the return values of the slot invocations.
   * Otherwise, the return value of the last slot invoked is returned.
   * @return The accumulated return values of the slot invocations.
   */
  result_type emit() const
    { return emitter_type::emit(impl_); }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Triggers the emission of the signal in reverse order (see emit()).
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  result_type emit_reverse() const
    { return emitter_type::emit_reverse(impl_); }
#endif // SIGCXX_DISABLE_DEPRECATED

  /** Triggers the emission of the signal (see emit()).
   *
   * @deprecated This is apparently not useful, but let us know if you need it.
   */
  result_type operator()() const
    { return emit(); }

  /** Creates a functor that calls emit() on this signal.
   * @code
   * sigc::mem_fun(mysignal, &sigc::signal0::emit)
   * @endcode
   * yields the same result.
   * @return A functor that calls emit() on this signal.
   */
  bound_const_mem_functor0<result_type, signal0> make_slot() const
    { return bound_const_mem_functor0<result_type, signal0>(*this, &signal0::emit); }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Creates an STL-style interface for the signal's list of slots.
   * This interface supports iteration, insertion and removal of slots.
   * @return An STL-style interface for the signal's list of slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  slot_list_type slots()
    { return slot_list_type(impl()); }

  /** Creates an STL-style interface for the signal's list of slots.
   * This interface supports iteration, insertion and removal of slots.
   * @return An STL-style interface for the signal's list of slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  const slot_list_type slots() const
    { return slot_list_type(const_cast<signal0*>(this)->impl()); }
#endif // SIGCXX_DISABLE_DEPRECATED

  signal0() {}

  signal0(const signal0& src)
    : signal_base(src) {}

  signal0(signal0&& src)
    : signal_base(std::move(src)) {}

  signal0& operator=(const signal0& src)
  {
    signal_base::operator=(src);
    return *this;
  }

  signal0& operator=(signal0&& src)
  {
    signal_base::operator=(std::move(src));
    return *this;
  }
};

/** Signal declaration.
 * signal1 can be used to connect() slots that are invoked
 * during subsequent calls to emit(). Any functor or slot
 * can be passed into connect(). It is converted into a slot
 * implicitly.
 *
 * If you want to connect one signal to another, use make_slot()
 * to retrieve a functor that emits the signal when invoked.
 *
 * Be careful if you directly pass one signal into the connect()
 * method of another: a shallow copy of the signal is made and
 * the signal's slots are not disconnected until both the signal
 * and its clone are destroyed, which is probably not what you want.
 *
 * The following template arguments are used:
 * - @e T_return The desired return type for the emit() function (may be overridden by the accumulator).
 * - @e T_arg1 Argument type used in the definition of emit().
 * - @e T_accumulator The accumulator type used for emission. The default
 * @p nil means that no accumulator should be used, for example if signal
 * emission returns the return value of the last slot invoked.
 *
 * You should use the more convenient unnumbered sigc::signal template.
 *
 * @ingroup signal
 */
template <class T_return, class T_arg1, class T_accumulator=nil>
class signal1
  : public signal_base
{
public:
  typedef internal::signal_emit1<T_return, T_arg1, T_accumulator> emitter_type;
  typedef typename emitter_type::result_type         result_type;
  typedef slot<T_return(T_arg1)>    slot_type;
  typedef slot_list<slot_type>                       slot_list_type;
  typedef typename slot_list_type::iterator               iterator;
  typedef typename slot_list_type::const_iterator         const_iterator;
  typedef typename slot_list_type::reverse_iterator       reverse_iterator;
  typedef typename slot_list_type::const_reverse_iterator const_reverse_iterator;

  /** Add a slot to the list of slots.
   * Any functor or slot may be passed into connect().
   * It will be converted into a slot implicitly.
   * The returned iterator may be stored for disconnection
   * of the slot at some later point. It stays valid until
   * the slot is removed from the list of slots. The iterator
   * can also be implicitly converted into a sigc::connection object
   * that may be used safely beyond the life time of the slot.
   *
   * std::function<> and C++11 lambda expressions are functors.
   * These are examples of functors that can be connected to a signal.
   *
   * %std::bind() creates a functor, but this functor typically has an
   * %operator()() which is a variadic template.
   * Our functor_trait can't deduce the result type
   * of such a functor. If you first assign the return value of %std::bind()
   * to a std::function, you can connect the std::function to a signal.
   *
   * @param slot_ The slot to add to the list of slots.
   * @return An iterator pointing to the new slot in the list.
   */
  iterator connect(const slot_type& slot_)
    { return iterator(signal_base::connect(static_cast<const slot_base&>(slot_))); }

  /** Add a slot to the list of slots.
   * @see connect(const slot_type& slot_).
   *
   * @newin{2,8}
   */
  iterator connect(slot_type&& slot_)
    { return iterator(signal_base::connect(std::move(static_cast<slot_base&>(slot_)))); }

  /** Triggers the emission of the signal.
   * During signal emission all slots that have been connected
   * to the signal are invoked unless they are manually set into
   * a blocking state. The parameters are passed on to the slots.
   * If @e T_accumulated is not @p nil, an accumulator of this type
   * is used to process the return values of the slot invocations.
   * Otherwise, the return value of the last slot invoked is returned.
   * @param _A_a1 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations.
   */
  result_type emit(type_trait_take_t<T_arg1> _A_a1) const
    { return emitter_type::emit(impl_, _A_a1); }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Triggers the emission of the signal in reverse order (see emit()).
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  result_type emit_reverse(type_trait_take_t<T_arg1> _A_a1) const
    { return emitter_type::emit_reverse(impl_, _A_a1); }
#endif // SIGCXX_DISABLE_DEPRECATED

  /** Triggers the emission of the signal (see emit()).
   *
   * @deprecated This is apparently not useful, but let us know if you need it.
   */
  result_type operator()(type_trait_take_t<T_arg1> _A_a1) const
    { return emit(_A_a1); }

  /** Creates a functor that calls emit() on this signal.
   * @code
   * sigc::mem_fun(mysignal, &sigc::signal1::emit)
   * @endcode
   * yields the same result.
   * @return A functor that calls emit() on this signal.
   */
  bound_const_mem_functor1<result_type, signal1, type_trait_take_t<T_arg1>> make_slot() const
    { return bound_const_mem_functor1<result_type, signal1, type_trait_take_t<T_arg1>>(*this, &signal1::emit); }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Creates an STL-style interface for the signal's list of slots.
   * This interface supports iteration, insertion and removal of slots.
   * @return An STL-style interface for the signal's list of slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  slot_list_type slots()
    { return slot_list_type(impl()); }

  /** Creates an STL-style interface for the signal's list of slots.
   * This interface supports iteration, insertion and removal of slots.
   * @return An STL-style interface for the signal's list of slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  const slot_list_type slots() const
    { return slot_list_type(const_cast<signal1*>(this)->impl()); }
#endif // SIGCXX_DISABLE_DEPRECATED

  signal1() {}

  signal1(const signal1& src)
    : signal_base(src) {}

  signal1(signal1&& src)
    : signal_base(std::move(src)) {}

  signal1& operator=(const signal1& src)
  {
    signal_base::operator=(src);
    return *this;
  }

  signal1& operator=(signal1&& src)
  {
    signal_base::operator=(std::move(src));
    return *this;
  }
};

/** Signal declaration.
 * signal2 can be used to connect() slots that are invoked
 * during subsequent calls to emit(). Any functor or slot
 * can be passed into connect(). It is converted into a slot
 * implicitly.
 *
 * If you want to connect one signal to another, use make_slot()
 * to retrieve a functor that emits the signal when invoked.
 *
 * Be careful if you directly pass one signal into the connect()
 * method of another: a shallow copy of the signal is made and
 * the signal's slots are not disconnected until both the signal
 * and its clone are destroyed, which is probably not what you want.
 *
 * The following template arguments are used:
 * - @e T_return The desired return type for the emit() function (may be overridden by the accumulator).
 * - @e T_arg1 Argument type used in the definition of emit().
 * - @e T_arg2 Argument type used in the definition of emit().
 * - @e T_accumulator The accumulator type used for emission. The default
 * @p nil means that no accumulator should be used, for example if signal
 * emission returns the return value of the last slot invoked.
 *
 * You should use the more convenient unnumbered sigc::signal template.
 *
 * @ingroup signal
 */
template <class T_return, class T_arg1, class T_arg2, class T_accumulator=nil>
class signal2
  : public signal_base
{
public:
  typedef internal::signal_emit2<T_return, T_arg1, T_arg2, T_accumulator> emitter_type;
  typedef typename emitter_type::result_type         result_type;
  typedef slot<T_return(T_arg1, T_arg2)>    slot_type;
  typedef slot_list<slot_type>                       slot_list_type;
  typedef typename slot_list_type::iterator               iterator;
  typedef typename slot_list_type::const_iterator         const_iterator;
  typedef typename slot_list_type::reverse_iterator       reverse_iterator;
  typedef typename slot_list_type::const_reverse_iterator const_reverse_iterator;

  /** Add a slot to the list of slots.
   * Any functor or slot may be passed into connect().
   * It will be converted into a slot implicitly.
   * The returned iterator may be stored for disconnection
   * of the slot at some later point. It stays valid until
   * the slot is removed from the list of slots. The iterator
   * can also be implicitly converted into a sigc::connection object
   * that may be used safely beyond the life time of the slot.
   *
   * std::function<> and C++11 lambda expressions are functors.
   * These are examples of functors that can be connected to a signal.
   *
   * %std::bind() creates a functor, but this functor typically has an
   * %operator()() which is a variadic template.
   * Our functor_trait can't deduce the result type
   * of such a functor. If you first assign the return value of %std::bind()
   * to a std::function, you can connect the std::function to a signal.
   *
   * @param slot_ The slot to add to the list of slots.
   * @return An iterator pointing to the new slot in the list.
   */
  iterator connect(const slot_type& slot_)
    { return iterator(signal_base::connect(static_cast<const slot_base&>(slot_))); }

  /** Add a slot to the list of slots.
   * @see connect(const slot_type& slot_).
   *
   * @newin{2,8}
   */
  iterator connect(slot_type&& slot_)
    { return iterator(signal_base::connect(std::move(static_cast<slot_base&>(slot_)))); }

  /** Triggers the emission of the signal.
   * During signal emission all slots that have been connected
   * to the signal are invoked unless they are manually set into
   * a blocking state. The parameters are passed on to the slots.
   * If @e T_accumulated is not @p nil, an accumulator of this type
   * is used to process the return values of the slot invocations.
   * Otherwise, the return value of the last slot invoked is returned.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations.
   */
  result_type emit(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
    { return emitter_type::emit(impl_, _A_a1, _A_a2); }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Triggers the emission of the signal in reverse order (see emit()).
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  result_type emit_reverse(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
    { return emitter_type::emit_reverse(impl_, _A_a1, _A_a2); }
#endif // SIGCXX_DISABLE_DEPRECATED

  /** Triggers the emission of the signal (see emit()).
   *
   * @deprecated This is apparently not useful, but let us know if you need it.
   */
  result_type operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
    { return emit(_A_a1, _A_a2); }

  /** Creates a functor that calls emit() on this signal.
   * @code
   * sigc::mem_fun(mysignal, &sigc::signal2::emit)
   * @endcode
   * yields the same result.
   * @return A functor that calls emit() on this signal.
   */
  bound_const_mem_functor2<result_type, signal2, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>> make_slot() const
    { return bound_const_mem_functor2<result_type, signal2, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>>(*this, &signal2::emit); }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Creates an STL-style interface for the signal's list of slots.
   * This interface supports iteration, insertion and removal of slots.
   * @return An STL-style interface for the signal's list of slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  slot_list_type slots()
    { return slot_list_type(impl()); }

  /** Creates an STL-style interface for the signal's list of slots.
   * This interface supports iteration, insertion and removal of slots.
   * @return An STL-style interface for the signal's list of slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  const slot_list_type slots() const
    { return slot_list_type(const_cast<signal2*>(this)->impl()); }
#endif // SIGCXX_DISABLE_DEPRECATED

  signal2() {}

  signal2(const signal2& src)
    : signal_base(src) {}

  signal2(signal2&& src)
    : signal_base(std::move(src)) {}

  signal2& operator=(const signal2& src)
  {
    signal_base::operator=(src);
    return *this;
  }

  signal2& operator=(signal2&& src)
  {
    signal_base::operator=(std::move(src));
    return *this;
  }
};

/** Signal declaration.
 * signal3 can be used to connect() slots that are invoked
 * during subsequent calls to emit(). Any functor or slot
 * can be passed into connect(). It is converted into a slot
 * implicitly.
 *
 * If you want to connect one signal to another, use make_slot()
 * to retrieve a functor that emits the signal when invoked.
 *
 * Be careful if you directly pass one signal into the connect()
 * method of another: a shallow copy of the signal is made and
 * the signal's slots are not disconnected until both the signal
 * and its clone are destroyed, which is probably not what you want.
 *
 * The following template arguments are used:
 * - @e T_return The desired return type for the emit() function (may be overridden by the accumulator).
 * - @e T_arg1 Argument type used in the definition of emit().
 * - @e T_arg2 Argument type used in the definition of emit().
 * - @e T_arg3 Argument type used in the definition of emit().
 * - @e T_accumulator The accumulator type used for emission. The default
 * @p nil means that no accumulator should be used, for example if signal
 * emission returns the return value of the last slot invoked.
 *
 * You should use the more convenient unnumbered sigc::signal template.
 *
 * @ingroup signal
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_accumulator=nil>
class signal3
  : public signal_base
{
public:
  typedef internal::signal_emit3<T_return, T_arg1, T_arg2, T_arg3, T_accumulator> emitter_type;
  typedef typename emitter_type::result_type         result_type;
  typedef slot<T_return(T_arg1, T_arg2, T_arg3)>    slot_type;
  typedef slot_list<slot_type>                       slot_list_type;
  typedef typename slot_list_type::iterator               iterator;
  typedef typename slot_list_type::const_iterator         const_iterator;
  typedef typename slot_list_type::reverse_iterator       reverse_iterator;
  typedef typename slot_list_type::const_reverse_iterator const_reverse_iterator;

  /** Add a slot to the list of slots.
   * Any functor or slot may be passed into connect().
   * It will be converted into a slot implicitly.
   * The returned iterator may be stored for disconnection
   * of the slot at some later point. It stays valid until
   * the slot is removed from the list of slots. The iterator
   * can also be implicitly converted into a sigc::connection object
   * that may be used safely beyond the life time of the slot.
   *
   * std::function<> and C++11 lambda expressions are functors.
   * These are examples of functors that can be connected to a signal.
   *
   * %std::bind() creates a functor, but this functor typically has an
   * %operator()() which is a variadic template.
   * Our functor_trait can't deduce the result type
   * of such a functor. If you first assign the return value of %std::bind()
   * to a std::function, you can connect the std::function to a signal.
   *
   * @param slot_ The slot to add to the list of slots.
   * @return An iterator pointing to the new slot in the list.
   */
  iterator connect(const slot_type& slot_)
    { return iterator(signal_base::connect(static_cast<const slot_base&>(slot_))); }

  /** Add a slot to the list of slots.
   * @see connect(const slot_type& slot_).
   *
   * @newin{2,8}
   */
  iterator connect(slot_type&& slot_)
    { return iterator(signal_base::connect(std::move(static_cast<slot_base&>(slot_)))); }

  /** Triggers the emission of the signal.
   * During signal emission all slots that have been connected
   * to the signal are invoked unless they are manually set into
   * a blocking state. The parameters are passed on to the slots.
   * If @e T_accumulated is not @p nil, an accumulator of this type
   * is used to process the return values of the slot invocations.
   * Otherwise, the return value of the last slot invoked is returned.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations.
   */
  result_type emit(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 emitter_type::emit(impl_, _A_a1, _A_a2, _A_a3); }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Triggers the emission of the signal in reverse order (see emit()).
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  result_type emit_reverse(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 emitter_type::emit_reverse(impl_, _A_a1, _A_a2, _A_a3); }
#endif // SIGCXX_DISABLE_DEPRECATED

  /** Triggers the emission of the signal (see emit()).
   *
   * @deprecated This is apparently not useful, but let us know if you need it.
   */
  result_type 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 emit(_A_a1, _A_a2, _A_a3); }

  /** Creates a functor that calls emit() on this signal.
   * @code
   * sigc::mem_fun(mysignal, &sigc::signal3::emit)
   * @endcode
   * yields the same result.
   * @return A functor that calls emit() on this signal.
   */
  bound_const_mem_functor3<result_type, signal3, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>> make_slot() const
    { return bound_const_mem_functor3<result_type, signal3, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>>(*this, &signal3::emit); }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Creates an STL-style interface for the signal's list of slots.
   * This interface supports iteration, insertion and removal of slots.
   * @return An STL-style interface for the signal's list of slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  slot_list_type slots()
    { return slot_list_type(impl()); }

  /** Creates an STL-style interface for the signal's list of slots.
   * This interface supports iteration, insertion and removal of slots.
   * @return An STL-style interface for the signal's list of slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  const slot_list_type slots() const
    { return slot_list_type(const_cast<signal3*>(this)->impl()); }
#endif // SIGCXX_DISABLE_DEPRECATED

  signal3() {}

  signal3(const signal3& src)
    : signal_base(src) {}

  signal3(signal3&& src)
    : signal_base(std::move(src)) {}

  signal3& operator=(const signal3& src)
  {
    signal_base::operator=(src);
    return *this;
  }

  signal3& operator=(signal3&& src)
  {
    signal_base::operator=(std::move(src));
    return *this;
  }
};

/** Signal declaration.
 * signal4 can be used to connect() slots that are invoked
 * during subsequent calls to emit(). Any functor or slot
 * can be passed into connect(). It is converted into a slot
 * implicitly.
 *
 * If you want to connect one signal to another, use make_slot()
 * to retrieve a functor that emits the signal when invoked.
 *
 * Be careful if you directly pass one signal into the connect()
 * method of another: a shallow copy of the signal is made and
 * the signal's slots are not disconnected until both the signal
 * and its clone are destroyed, which is probably not what you want.
 *
 * The following template arguments are used:
 * - @e T_return The desired return type for the emit() function (may be overridden by the accumulator).
 * - @e T_arg1 Argument type used in the definition of emit().
 * - @e T_arg2 Argument type used in the definition of emit().
 * - @e T_arg3 Argument type used in the definition of emit().
 * - @e T_arg4 Argument type used in the definition of emit().
 * - @e T_accumulator The accumulator type used for emission. The default
 * @p nil means that no accumulator should be used, for example if signal
 * emission returns the return value of the last slot invoked.
 *
 * You should use the more convenient unnumbered sigc::signal template.
 *
 * @ingroup signal
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_accumulator=nil>
class signal4
  : public signal_base
{
public:
  typedef internal::signal_emit4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator> emitter_type;
  typedef typename emitter_type::result_type         result_type;
  typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4)>    slot_type;
  typedef slot_list<slot_type>                       slot_list_type;
  typedef typename slot_list_type::iterator               iterator;
  typedef typename slot_list_type::const_iterator         const_iterator;
  typedef typename slot_list_type::reverse_iterator       reverse_iterator;
  typedef typename slot_list_type::const_reverse_iterator const_reverse_iterator;

  /** Add a slot to the list of slots.
   * Any functor or slot may be passed into connect().
   * It will be converted into a slot implicitly.
   * The returned iterator may be stored for disconnection
   * of the slot at some later point. It stays valid until
   * the slot is removed from the list of slots. The iterator
   * can also be implicitly converted into a sigc::connection object
   * that may be used safely beyond the life time of the slot.
   *
   * std::function<> and C++11 lambda expressions are functors.
   * These are examples of functors that can be connected to a signal.
   *
   * %std::bind() creates a functor, but this functor typically has an
   * %operator()() which is a variadic template.
   * Our functor_trait can't deduce the result type
   * of such a functor. If you first assign the return value of %std::bind()
   * to a std::function, you can connect the std::function to a signal.
   *
   * @param slot_ The slot to add to the list of slots.
   * @return An iterator pointing to the new slot in the list.
   */
  iterator connect(const slot_type& slot_)
    { return iterator(signal_base::connect(static_cast<const slot_base&>(slot_))); }

  /** Add a slot to the list of slots.
   * @see connect(const slot_type& slot_).
   *
   * @newin{2,8}
   */
  iterator connect(slot_type&& slot_)
    { return iterator(signal_base::connect(std::move(static_cast<slot_base&>(slot_)))); }

  /** Triggers the emission of the signal.
   * During signal emission all slots that have been connected
   * to the signal are invoked unless they are manually set into
   * a blocking state. The parameters are passed on to the slots.
   * If @e T_accumulated is not @p nil, an accumulator of this type
   * is used to process the return values of the slot invocations.
   * Otherwise, the return value of the last slot invoked is returned.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations.
   */
  result_type emit(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 emitter_type::emit(impl_, _A_a1, _A_a2, _A_a3, _A_a4); }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Triggers the emission of the signal in reverse order (see emit()).
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  result_type emit_reverse(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 emitter_type::emit_reverse(impl_, _A_a1, _A_a2, _A_a3, _A_a4); }
#endif // SIGCXX_DISABLE_DEPRECATED

  /** Triggers the emission of the signal (see emit()).
   *
   * @deprecated This is apparently not useful, but let us know if you need it.
   */
  result_type 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 emit(_A_a1, _A_a2, _A_a3, _A_a4); }

  /** Creates a functor that calls emit() on this signal.
   * @code
   * sigc::mem_fun(mysignal, &sigc::signal4::emit)
   * @endcode
   * yields the same result.
   * @return A functor that calls emit() on this signal.
   */
  bound_const_mem_functor4<result_type, signal4, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>> make_slot() const
    { return bound_const_mem_functor4<result_type, signal4, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>>(*this, &signal4::emit); }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Creates an STL-style interface for the signal's list of slots.
   * This interface supports iteration, insertion and removal of slots.
   * @return An STL-style interface for the signal's list of slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  slot_list_type slots()
    { return slot_list_type(impl()); }

  /** Creates an STL-style interface for the signal's list of slots.
   * This interface supports iteration, insertion and removal of slots.
   * @return An STL-style interface for the signal's list of slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  const slot_list_type slots() const
    { return slot_list_type(const_cast<signal4*>(this)->impl()); }
#endif // SIGCXX_DISABLE_DEPRECATED

  signal4() {}

  signal4(const signal4& src)
    : signal_base(src) {}

  signal4(signal4&& src)
    : signal_base(std::move(src)) {}

  signal4& operator=(const signal4& src)
  {
    signal_base::operator=(src);
    return *this;
  }

  signal4& operator=(signal4&& src)
  {
    signal_base::operator=(std::move(src));
    return *this;
  }
};

/** Signal declaration.
 * signal5 can be used to connect() slots that are invoked
 * during subsequent calls to emit(). Any functor or slot
 * can be passed into connect(). It is converted into a slot
 * implicitly.
 *
 * If you want to connect one signal to another, use make_slot()
 * to retrieve a functor that emits the signal when invoked.
 *
 * Be careful if you directly pass one signal into the connect()
 * method of another: a shallow copy of the signal is made and
 * the signal's slots are not disconnected until both the signal
 * and its clone are destroyed, which is probably not what you want.
 *
 * The following template arguments are used:
 * - @e T_return The desired return type for the emit() function (may be overridden by the accumulator).
 * - @e T_arg1 Argument type used in the definition of emit().
 * - @e T_arg2 Argument type used in the definition of emit().
 * - @e T_arg3 Argument type used in the definition of emit().
 * - @e T_arg4 Argument type used in the definition of emit().
 * - @e T_arg5 Argument type used in the definition of emit().
 * - @e T_accumulator The accumulator type used for emission. The default
 * @p nil means that no accumulator should be used, for example if signal
 * emission returns the return value of the last slot invoked.
 *
 * You should use the more convenient unnumbered sigc::signal template.
 *
 * @ingroup signal
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_accumulator=nil>
class signal5
  : public signal_base
{
public:
  typedef internal::signal_emit5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator> emitter_type;
  typedef typename emitter_type::result_type         result_type;
  typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>    slot_type;
  typedef slot_list<slot_type>                       slot_list_type;
  typedef typename slot_list_type::iterator               iterator;
  typedef typename slot_list_type::const_iterator         const_iterator;
  typedef typename slot_list_type::reverse_iterator       reverse_iterator;
  typedef typename slot_list_type::const_reverse_iterator const_reverse_iterator;

  /** Add a slot to the list of slots.
   * Any functor or slot may be passed into connect().
   * It will be converted into a slot implicitly.
   * The returned iterator may be stored for disconnection
   * of the slot at some later point. It stays valid until
   * the slot is removed from the list of slots. The iterator
   * can also be implicitly converted into a sigc::connection object
   * that may be used safely beyond the life time of the slot.
   *
   * std::function<> and C++11 lambda expressions are functors.
   * These are examples of functors that can be connected to a signal.
   *
   * %std::bind() creates a functor, but this functor typically has an
   * %operator()() which is a variadic template.
   * Our functor_trait can't deduce the result type
   * of such a functor. If you first assign the return value of %std::bind()
   * to a std::function, you can connect the std::function to a signal.
   *
   * @param slot_ The slot to add to the list of slots.
   * @return An iterator pointing to the new slot in the list.
   */
  iterator connect(const slot_type& slot_)
    { return iterator(signal_base::connect(static_cast<const slot_base&>(slot_))); }

  /** Add a slot to the list of slots.
   * @see connect(const slot_type& slot_).
   *
   * @newin{2,8}
   */
  iterator connect(slot_type&& slot_)
    { return iterator(signal_base::connect(std::move(static_cast<slot_base&>(slot_)))); }

  /** Triggers the emission of the signal.
   * During signal emission all slots that have been connected
   * to the signal are invoked unless they are manually set into
   * a blocking state. The parameters are passed on to the slots.
   * If @e T_accumulated is not @p nil, an accumulator of this type
   * is used to process the return values of the slot invocations.
   * Otherwise, the return value of the last slot invoked is returned.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations.
   */
  result_type emit(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 emitter_type::emit(impl_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Triggers the emission of the signal in reverse order (see emit()).
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  result_type emit_reverse(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 emitter_type::emit_reverse(impl_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
#endif // SIGCXX_DISABLE_DEPRECATED

  /** Triggers the emission of the signal (see emit()).
   *
   * @deprecated This is apparently not useful, but let us know if you need it.
   */
  result_type 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 emit(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }

  /** Creates a functor that calls emit() on this signal.
   * @code
   * sigc::mem_fun(mysignal, &sigc::signal5::emit)
   * @endcode
   * yields the same result.
   * @return A functor that calls emit() on this signal.
   */
  bound_const_mem_functor5<result_type, signal5, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>, type_trait_take_t<T_arg5>> make_slot() const
    { return bound_const_mem_functor5<result_type, signal5, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>, type_trait_take_t<T_arg5>>(*this, &signal5::emit); }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Creates an STL-style interface for the signal's list of slots.
   * This interface supports iteration, insertion and removal of slots.
   * @return An STL-style interface for the signal's list of slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  slot_list_type slots()
    { return slot_list_type(impl()); }

  /** Creates an STL-style interface for the signal's list of slots.
   * This interface supports iteration, insertion and removal of slots.
   * @return An STL-style interface for the signal's list of slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  const slot_list_type slots() const
    { return slot_list_type(const_cast<signal5*>(this)->impl()); }
#endif // SIGCXX_DISABLE_DEPRECATED

  signal5() {}

  signal5(const signal5& src)
    : signal_base(src) {}

  signal5(signal5&& src)
    : signal_base(std::move(src)) {}

  signal5& operator=(const signal5& src)
  {
    signal_base::operator=(src);
    return *this;
  }

  signal5& operator=(signal5&& src)
  {
    signal_base::operator=(std::move(src));
    return *this;
  }
};

/** Signal declaration.
 * signal6 can be used to connect() slots that are invoked
 * during subsequent calls to emit(). Any functor or slot
 * can be passed into connect(). It is converted into a slot
 * implicitly.
 *
 * If you want to connect one signal to another, use make_slot()
 * to retrieve a functor that emits the signal when invoked.
 *
 * Be careful if you directly pass one signal into the connect()
 * method of another: a shallow copy of the signal is made and
 * the signal's slots are not disconnected until both the signal
 * and its clone are destroyed, which is probably not what you want.
 *
 * The following template arguments are used:
 * - @e T_return The desired return type for the emit() function (may be overridden by the accumulator).
 * - @e T_arg1 Argument type used in the definition of emit().
 * - @e T_arg2 Argument type used in the definition of emit().
 * - @e T_arg3 Argument type used in the definition of emit().
 * - @e T_arg4 Argument type used in the definition of emit().
 * - @e T_arg5 Argument type used in the definition of emit().
 * - @e T_arg6 Argument type used in the definition of emit().
 * - @e T_accumulator The accumulator type used for emission. The default
 * @p nil means that no accumulator should be used, for example if signal
 * emission returns the return value of the last slot invoked.
 *
 * You should use the more convenient unnumbered sigc::signal template.
 *
 * @ingroup signal
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_accumulator=nil>
class signal6
  : public signal_base
{
public:
  typedef internal::signal_emit6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator> emitter_type;
  typedef typename emitter_type::result_type         result_type;
  typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>    slot_type;
  typedef slot_list<slot_type>                       slot_list_type;
  typedef typename slot_list_type::iterator               iterator;
  typedef typename slot_list_type::const_iterator         const_iterator;
  typedef typename slot_list_type::reverse_iterator       reverse_iterator;
  typedef typename slot_list_type::const_reverse_iterator const_reverse_iterator;

  /** Add a slot to the list of slots.
   * Any functor or slot may be passed into connect().
   * It will be converted into a slot implicitly.
   * The returned iterator may be stored for disconnection
   * of the slot at some later point. It stays valid until
   * the slot is removed from the list of slots. The iterator
   * can also be implicitly converted into a sigc::connection object
   * that may be used safely beyond the life time of the slot.
   *
   * std::function<> and C++11 lambda expressions are functors.
   * These are examples of functors that can be connected to a signal.
   *
   * %std::bind() creates a functor, but this functor typically has an
   * %operator()() which is a variadic template.
   * Our functor_trait can't deduce the result type
   * of such a functor. If you first assign the return value of %std::bind()
   * to a std::function, you can connect the std::function to a signal.
   *
   * @param slot_ The slot to add to the list of slots.
   * @return An iterator pointing to the new slot in the list.
   */
  iterator connect(const slot_type& slot_)
    { return iterator(signal_base::connect(static_cast<const slot_base&>(slot_))); }

  /** Add a slot to the list of slots.
   * @see connect(const slot_type& slot_).
   *
   * @newin{2,8}
   */
  iterator connect(slot_type&& slot_)
    { return iterator(signal_base::connect(std::move(static_cast<slot_base&>(slot_)))); }

  /** Triggers the emission of the signal.
   * During signal emission all slots that have been connected
   * to the signal are invoked unless they are manually set into
   * a blocking state. The parameters are passed on to the slots.
   * If @e T_accumulated is not @p nil, an accumulator of this type
   * is used to process the return values of the slot invocations.
   * Otherwise, the return value of the last slot invoked is returned.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @param _A_a6 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations.
   */
  result_type emit(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 emitter_type::emit(impl_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Triggers the emission of the signal in reverse order (see emit()).
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  result_type emit_reverse(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 emitter_type::emit_reverse(impl_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
#endif // SIGCXX_DISABLE_DEPRECATED

  /** Triggers the emission of the signal (see emit()).
   *
   * @deprecated This is apparently not useful, but let us know if you need it.
   */
  result_type 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 emit(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }

  /** Creates a functor that calls emit() on this signal.
   * @code
   * sigc::mem_fun(mysignal, &sigc::signal6::emit)
   * @endcode
   * yields the same result.
   * @return A functor that calls emit() on this signal.
   */
  bound_const_mem_functor6<result_type, signal6, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>, type_trait_take_t<T_arg5>, type_trait_take_t<T_arg6>> make_slot() const
    { return bound_const_mem_functor6<result_type, signal6, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>, type_trait_take_t<T_arg5>, type_trait_take_t<T_arg6>>(*this, &signal6::emit); }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Creates an STL-style interface for the signal's list of slots.
   * This interface supports iteration, insertion and removal of slots.
   * @return An STL-style interface for the signal's list of slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  slot_list_type slots()
    { return slot_list_type(impl()); }

  /** Creates an STL-style interface for the signal's list of slots.
   * This interface supports iteration, insertion and removal of slots.
   * @return An STL-style interface for the signal's list of slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  const slot_list_type slots() const
    { return slot_list_type(const_cast<signal6*>(this)->impl()); }
#endif // SIGCXX_DISABLE_DEPRECATED

  signal6() {}

  signal6(const signal6& src)
    : signal_base(src) {}

  signal6(signal6&& src)
    : signal_base(std::move(src)) {}

  signal6& operator=(const signal6& src)
  {
    signal_base::operator=(src);
    return *this;
  }

  signal6& operator=(signal6&& src)
  {
    signal_base::operator=(std::move(src));
    return *this;
  }
};

/** Signal declaration.
 * signal7 can be used to connect() slots that are invoked
 * during subsequent calls to emit(). Any functor or slot
 * can be passed into connect(). It is converted into a slot
 * implicitly.
 *
 * If you want to connect one signal to another, use make_slot()
 * to retrieve a functor that emits the signal when invoked.
 *
 * Be careful if you directly pass one signal into the connect()
 * method of another: a shallow copy of the signal is made and
 * the signal's slots are not disconnected until both the signal
 * and its clone are destroyed, which is probably not what you want.
 *
 * The following template arguments are used:
 * - @e T_return The desired return type for the emit() function (may be overridden by the accumulator).
 * - @e T_arg1 Argument type used in the definition of emit().
 * - @e T_arg2 Argument type used in the definition of emit().
 * - @e T_arg3 Argument type used in the definition of emit().
 * - @e T_arg4 Argument type used in the definition of emit().
 * - @e T_arg5 Argument type used in the definition of emit().
 * - @e T_arg6 Argument type used in the definition of emit().
 * - @e T_arg7 Argument type used in the definition of emit().
 * - @e T_accumulator The accumulator type used for emission. The default
 * @p nil means that no accumulator should be used, for example if signal
 * emission returns the return value of the last slot invoked.
 *
 * You should use the more convenient unnumbered sigc::signal template.
 *
 * @ingroup signal
 */
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 T_accumulator=nil>
class signal7
  : public signal_base
{
public:
  typedef internal::signal_emit7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator> emitter_type;
  typedef typename emitter_type::result_type         result_type;
  typedef slot<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>    slot_type;
  typedef slot_list<slot_type>                       slot_list_type;
  typedef typename slot_list_type::iterator               iterator;
  typedef typename slot_list_type::const_iterator         const_iterator;
  typedef typename slot_list_type::reverse_iterator       reverse_iterator;
  typedef typename slot_list_type::const_reverse_iterator const_reverse_iterator;

  /** Add a slot to the list of slots.
   * Any functor or slot may be passed into connect().
   * It will be converted into a slot implicitly.
   * The returned iterator may be stored for disconnection
   * of the slot at some later point. It stays valid until
   * the slot is removed from the list of slots. The iterator
   * can also be implicitly converted into a sigc::connection object
   * that may be used safely beyond the life time of the slot.
   *
   * std::function<> and C++11 lambda expressions are functors.
   * These are examples of functors that can be connected to a signal.
   *
   * %std::bind() creates a functor, but this functor typically has an
   * %operator()() which is a variadic template.
   * Our functor_trait can't deduce the result type
   * of such a functor. If you first assign the return value of %std::bind()
   * to a std::function, you can connect the std::function to a signal.
   *
   * @param slot_ The slot to add to the list of slots.
   * @return An iterator pointing to the new slot in the list.
   */
  iterator connect(const slot_type& slot_)
    { return iterator(signal_base::connect(static_cast<const slot_base&>(slot_))); }

  /** Add a slot to the list of slots.
   * @see connect(const slot_type& slot_).
   *
   * @newin{2,8}
   */
  iterator connect(slot_type&& slot_)
    { return iterator(signal_base::connect(std::move(static_cast<slot_base&>(slot_)))); }

  /** Triggers the emission of the signal.
   * During signal emission all slots that have been connected
   * to the signal are invoked unless they are manually set into
   * a blocking state. The parameters are passed on to the slots.
   * If @e T_accumulated is not @p nil, an accumulator of this type
   * is used to process the return values of the slot invocations.
   * Otherwise, the return value of the last slot invoked is returned.
   * @param _A_a1 Argument to be passed on to the slots.
   * @param _A_a2 Argument to be passed on to the slots.
   * @param _A_a3 Argument to be passed on to the slots.
   * @param _A_a4 Argument to be passed on to the slots.
   * @param _A_a5 Argument to be passed on to the slots.
   * @param _A_a6 Argument to be passed on to the slots.
   * @param _A_a7 Argument to be passed on to the slots.
   * @return The accumulated return values of the slot invocations.
   */
  result_type emit(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 emitter_type::emit(impl_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Triggers the emission of the signal in reverse order (see emit()).
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  result_type emit_reverse(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 emitter_type::emit_reverse(impl_, _A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
#endif // SIGCXX_DISABLE_DEPRECATED

  /** Triggers the emission of the signal (see emit()).
   *
   * @deprecated This is apparently not useful, but let us know if you need it.
   */
  result_type 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 emit(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }

  /** Creates a functor that calls emit() on this signal.
   * @code
   * sigc::mem_fun(mysignal, &sigc::signal7::emit)
   * @endcode
   * yields the same result.
   * @return A functor that calls emit() on this signal.
   */
  bound_const_mem_functor7<result_type, signal7, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>, type_trait_take_t<T_arg5>, type_trait_take_t<T_arg6>, type_trait_take_t<T_arg7>> make_slot() const
    { return bound_const_mem_functor7<result_type, signal7, type_trait_take_t<T_arg1>, type_trait_take_t<T_arg2>, type_trait_take_t<T_arg3>, type_trait_take_t<T_arg4>, type_trait_take_t<T_arg5>, type_trait_take_t<T_arg6>, type_trait_take_t<T_arg7>>(*this, &signal7::emit); }

#ifndef SIGCXX_DISABLE_DEPRECATED
  /** Creates an STL-style interface for the signal's list of slots.
   * This interface supports iteration, insertion and removal of slots.
   * @return An STL-style interface for the signal's list of slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  slot_list_type slots()
    { return slot_list_type(impl()); }

  /** Creates an STL-style interface for the signal's list of slots.
   * This interface supports iteration, insertion and removal of slots.
   * @return An STL-style interface for the signal's list of slots.
   *
   * @deprecated This is apparently not useful, but please let us know if you need it.
   */
  const slot_list_type slots() const
    { return slot_list_type(const_cast<signal7*>(this)->impl()); }
#endif // SIGCXX_DISABLE_DEPRECATED

  signal7() {}

  signal7(const signal7& src)
    : signal_base(src) {}

  signal7(signal7&& src)
    : signal_base(std::move(src)) {}

  signal7& operator=(const signal7& src)
  {
    signal_base::operator=(src);
    return *this;
  }

  signal7& operator=(signal7&& src)
  {
    signal_base::operator=(std::move(src));
    return *this;
  }
};



/** Convenience wrapper for the numbered sigc::signal# templates.
 * signal can be used to connect() slots that are invoked
 * during subsequent calls to emit(). Any functor or slot
 * can be passed into connect(). It is converted into a slot
 * implicitly.
 *
 * If you want to connect one signal to another, use make_slot()
 * to retrieve a functor that emits the signal when invoked.
 *
 * Be careful if you directly pass one signal into the connect()
 * method of another: a shallow copy of the signal is made and
 * the signal's slots are not disconnected until both the signal
 * and its clone are destroyed, which is probably not what you want!
 *
 * The template arguments determine the function signature of
 * the emit() function:
 * - @e T_return The desired return type of the emit() function.
 * - @e T_arg1 Argument type used in the definition of emit(). The default @p nil means no argument.
 * - @e T_arg2 Argument type used in the definition of emit(). The default @p nil means no argument.
 * - @e T_arg3 Argument type used in the definition of emit(). The default @p nil means no argument.
 * - @e T_arg4 Argument type used in the definition of emit(). The default @p nil means no argument.
 * - @e T_arg5 Argument type used in the definition of emit(). The default @p nil means no argument.
 * - @e T_arg6 Argument type used in the definition of emit(). The default @p nil means no argument.
 * - @e T_arg7 Argument type used in the definition of emit(). The default @p nil means no argument.
 *
 * To specify an accumulator type the nested class signal::accumulated can be used.
 *
 * @par Example:
 * @code
 * void foo(int) {}
 * sigc::signal<void, long> sig;
 * sig.connect(sigc::ptr_fun(&foo));
 * sig.emit(19);
 * @endcode
 *
 * @deprecated Please use the syntax similar to that used by std::function<>:
 * @code
 * sigc::slot<void(bool, int)> some_slot;
 * @endcode
 *
 * @ingroup signal
 */
template <class T_return, class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil>
class signal
  : public signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>
{
public:
  /** Convenience wrapper for the numbered sigc::signal# templates.
   * Like sigc::signal but the additional template parameter @e T_accumulator
   * defines the accumulator type that should be used.
   *
   * An accumulator is a functor that uses a pair of special iterators
   * to step through a list of slots and calculate a return value
   * from the results of the slot invokations. The iterators' operator*()
   * executes the slot. The return value is buffered, so that in an expression
   * like @code a = (*i) * (*i); @endcode the slot is executed only once.
   * The accumulator must define its return value as @p result_type.
   * 
   * @par Example 1:
   * This accumulator calculates the arithmetic mean value:
   * @code
   * struct arithmetic_mean_accumulator
   * {
   *   typedef double result_type;
   *   template<typename T_iterator>
   *   result_type operator()(T_iterator first, T_iterator last) const
   *   {
   *     result_type value_ = 0;
   *     int n_ = 0;
   *     for (; first != last; ++first, ++n_)
   *       value_ += *first;
   *     return value_ / n_;
   *   }
   * };
   * @endcode
   *
   * @par Example 2:
   * This accumulator stops signal emission when a slot returns zero:
   * @code
   * struct interruptable_accumulator
   * {
   *   typedef bool result_type;
   *   template<typename T_iterator>
   *   result_type operator()(T_iterator first, T_iterator last) const
   *   {
   *     for (; first != last; ++first, ++n_)
   *       if (!*first) return false;
   *     return true;
   *   }
   * };
   * @endcode
   *
   * @ingroup signal
   */
  template <class T_accumulator>
  class accumulated
    : public signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator>
  {
  public:
    accumulated() {}
    accumulated(const accumulated& src)
      : signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator>(src) {}
  };

  signal() {}

  signal(const signal& src)
    : signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>(src) {}

  signal(signal&& src)
    : signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>(std::move(src)) {}

  signal& operator=(const signal& src)
  {
    signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>::operator=(src);
    return *this;
  }

  signal& operator=(signal&& src)
  {
    signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>::operator=(std::move(src));
    return *this;
  }
};

/**
 * This specialization allow use of the  sigc::signal<R(Args...)> syntax,
 */
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 signal<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)>
  : public signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>
{
public:
  /** Convenience wrapper for the numbered sigc::signal# templates.
   * Like sigc::signal but the additional template parameter @e T_accumulator
   * defines the accumulator type that should be used.
   *
   * An accumulator is a functor that uses a pair of special iterators
   * to step through a list of slots and calculate a return value
   * from the results of the slot invokations. The iterators' operator*()
   * executes the slot. The return value is buffered, so that in an expression
   * like @code a = (*i) * (*i); @endcode the slot is executed only once.
   * The accumulator must define its return value as @p result_type.
   *
   * @par Example 1:
   * This accumulator calculates the arithmetic mean value:
   * @code
   * struct arithmetic_mean_accumulator
   * {
   *   typedef double result_type;
   *   template<typename T_iterator>
   *   result_type operator()(T_iterator first, T_iterator last) const
   *   {
   *     result_type value_ = 0;
   *     int n_ = 0;
   *     for (; first != last; ++first, ++n_)
   *       value_ += *first;
   *     return value_ / n_;
   *   }
   * };
   * @endcode
   *
   * @par Example 2:
   * This accumulator stops signal emission when a slot returns zero:
   * @code
   * struct interruptable_accumulator
   * {
   *   typedef bool result_type;
   *   template<typename T_iterator>
   *   result_type operator()(T_iterator first, T_iterator last) const
   *   {
   *     for (; first != last; ++first, ++n_)
   *       if (!*first) return false;
   *     return true;
   *   }
   * };
   * @endcode
   *
   * @ingroup signal
   */
  template <class T_accumulator>
  class accumulated
    : public signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator>
  {
  public:
    accumulated() {}
    accumulated(const accumulated& src)
      : signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_accumulator>(src) {}
  };

  signal() {}

  signal(const signal& src)
    : signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>(src) {}

  signal(signal&& src)
    : signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>(std::move(src)) {}

  signal& operator=(const signal& src)
  {
    signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>::operator=(src);
    return *this;
  }

  signal& operator=(signal&& src)
  {
    signal7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, nil>::operator=(std::move(src));
    return *this;
  }
};




/** Convenience wrapper for the numbered sigc::signal0 template.
 * See the base class for useful methods.
 * This is the template specialization of the unnumbered sigc::signal
 * template for 0 argument(s).
 *
 * @deprecated Please use the syntax similar to that used by std::function<>:
 * @code
 * sigc::slot<void(bool, int)> some_slot;
 * @endcode
 */
template <class T_return>
class signal <T_return, nil, nil, nil, nil, nil, nil, nil>
  : public signal0<T_return, nil>
{
public:

  /** Convenience wrapper for the numbered sigc::signal0 template.
   * Like sigc::signal but the additional template parameter @e T_accumulator
   * defines the accumulator type that should be used.
   */
  template <class T_accumulator>
  class accumulated
    : public signal0<T_return, T_accumulator>
  {
  public:
    accumulated() {}
    accumulated(const accumulated& src)
      : signal0<T_return, T_accumulator>(src) {}
  };

  signal() {}

  signal(const signal& src)
    : signal0<T_return, nil>(src) {}

  signal(signal&& src)
    : signal0<T_return, nil>(std::move(src)) {}

  signal& operator=(const signal& src)
  {
    signal0<T_return, nil>::operator=(src);
    return *this;
  }

  signal& operator=(signal&& src)
  {
    signal0<T_return, nil>::operator=(std::move(src));
    return *this;
  }
};

/**
 * This specialization allow use of the  sigc::signal<R(Args...)> syntax,
 */
template <class T_return>
class signal<T_return()>
  : public signal0<T_return, nil>
{
public:

  /** Convenience wrapper for the numbered sigc::signal0 template.
   * Like sigc::signal but the additional template parameter @e T_accumulator
   * defines the accumulator type that should be used.
   */
  template <class T_accumulator>
  class accumulated
    : public signal0<T_return, T_accumulator>
  {
  public:
    accumulated() {}
    accumulated(const accumulated& src)
      : signal0<T_return, T_accumulator>(src) {}
  };

  signal() {}

  signal(const signal& src)
    : signal0<T_return, nil>(src) {}

  signal(signal&& src)
    : signal0<T_return, nil>(std::move(src)) {}

  signal& operator=(const signal& src)
  {
    signal0<T_return, nil>::operator=(src);
    return *this;
  }

  signal& operator=(signal&& src)
  {
    signal0<T_return, nil>::operator=(std::move(src));
    return *this;
  }
};



/** Convenience wrapper for the numbered sigc::signal1 template.
 * See the base class for useful methods.
 * This is the template specialization of the unnumbered sigc::signal
 * template for 1 argument(s).
 *
 * @deprecated Please use the syntax similar to that used by std::function<>:
 * @code
 * sigc::slot<void(bool, int)> some_slot;
 * @endcode
 */
template <class T_return, class T_arg1>
class signal <T_return, T_arg1, nil, nil, nil, nil, nil, nil>
  : public signal1<T_return, T_arg1, nil>
{
public:

  /** Convenience wrapper for the numbered sigc::signal1 template.
   * Like sigc::signal but the additional template parameter @e T_accumulator
   * defines the accumulator type that should be used.
   */
  template <class T_accumulator>
  class accumulated
    : public signal1<T_return, T_arg1, T_accumulator>
  {
  public:
    accumulated() {}
    accumulated(const accumulated& src)
      : signal1<T_return, T_arg1, T_accumulator>(src) {}
  };

  signal() {}

  signal(const signal& src)
    : signal1<T_return, T_arg1, nil>(src) {}

  signal(signal&& src)
    : signal1<T_return, T_arg1, nil>(std::move(src)) {}

  signal& operator=(const signal& src)
  {
    signal1<T_return, T_arg1, nil>::operator=(src);
    return *this;
  }

  signal& operator=(signal&& src)
  {
    signal1<T_return, T_arg1, nil>::operator=(std::move(src));
    return *this;
  }
};

/**
 * This specialization allow use of the  sigc::signal<R(Args...)> syntax,
 */
template <class T_return, class T_arg1>
class signal<T_return(T_arg1)>
  : public signal1<T_return, T_arg1, nil>
{
public:

  /** Convenience wrapper for the numbered sigc::signal1 template.
   * Like sigc::signal but the additional template parameter @e T_accumulator
   * defines the accumulator type that should be used.
   */
  template <class T_accumulator>
  class accumulated
    : public signal1<T_return, T_arg1, T_accumulator>
  {
  public:
    accumulated() {}
    accumulated(const accumulated& src)
      : signal1<T_return, T_arg1, T_accumulator>(src) {}
  };

  signal() {}

  signal(const signal& src)
    : signal1<T_return, T_arg1, nil>(src) {}

  signal(signal&& src)
    : signal1<T_return, T_arg1, nil>(std::move(src)) {}

  signal& operator=(const signal& src)
  {
    signal1<T_return, T_arg1, nil>::operator=(src);
    return *this;
  }

  signal& operator=(signal&& src)
  {
    signal1<T_return, T_arg1, nil>::operator=(std::move(src));
    return *this;
  }
};



/** Convenience wrapper for the numbered sigc::signal2 template.
 * See the base class for useful methods.
 * This is the template specialization of the unnumbered sigc::signal
 * template for 2 argument(s).
 *
 * @deprecated Please use the syntax similar to that used by std::function<>:
 * @code
 * sigc::slot<void(bool, int)> some_slot;
 * @endcode
 */
template <class T_return, class T_arg1, class T_arg2>
class signal <T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil>
  : public signal2<T_return, T_arg1, T_arg2, nil>
{
public:

  /** Convenience wrapper for the numbered sigc::signal2 template.
   * Like sigc::signal but the additional template parameter @e T_accumulator
   * defines the accumulator type that should be used.
   */
  template <class T_accumulator>
  class accumulated
    : public signal2<T_return, T_arg1, T_arg2, T_accumulator>
  {
  public:
    accumulated() {}
    accumulated(const accumulated& src)
      : signal2<T_return, T_arg1, T_arg2, T_accumulator>(src) {}
  };

  signal() {}

  signal(const signal& src)
    : signal2<T_return, T_arg1, T_arg2, nil>(src) {}

  signal(signal&& src)
    : signal2<T_return, T_arg1, T_arg2, nil>(std::move(src)) {}

  signal& operator=(const signal& src)
  {
    signal2<T_return, T_arg1, T_arg2, nil>::operator=(src);
    return *this;
  }

  signal& operator=(signal&& src)
  {
    signal2<T_return, T_arg1, T_arg2, nil>::operator=(std::move(src));
    return *this;
  }
};

/**
 * This specialization allow use of the  sigc::signal<R(Args...)> syntax,
 */
template <class T_return, class T_arg1, class T_arg2>
class signal<T_return(T_arg1, T_arg2)>
  : public signal2<T_return, T_arg1, T_arg2, nil>
{
public:

  /** Convenience wrapper for the numbered sigc::signal2 template.
   * Like sigc::signal but the additional template parameter @e T_accumulator
   * defines the accumulator type that should be used.
   */
  template <class T_accumulator>
  class accumulated
    : public signal2<T_return, T_arg1, T_arg2, T_accumulator>
  {
  public:
    accumulated() {}
    accumulated(const accumulated& src)
      : signal2<T_return, T_arg1, T_arg2, T_accumulator>(src) {}
  };

  signal() {}

  signal(const signal& src)
    : signal2<T_return, T_arg1, T_arg2, nil>(src) {}

  signal(signal&& src)
    : signal2<T_return, T_arg1, T_arg2, nil>(std::move(src)) {}

  signal& operator=(const signal& src)
  {
    signal2<T_return, T_arg1, T_arg2, nil>::operator=(src);
    return *this;
  }

  signal& operator=(signal&& src)
  {
    signal2<T_return, T_arg1, T_arg2, nil>::operator=(std::move(src));
    return *this;
  }
};



/** Convenience wrapper for the numbered sigc::signal3 template.
 * See the base class for useful methods.
 * This is the template specialization of the unnumbered sigc::signal
 * template for 3 argument(s).
 *
 * @deprecated Please use the syntax similar to that used by std::function<>:
 * @code
 * sigc::slot<void(bool, int)> some_slot;
 * @endcode
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3>
class signal <T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil>
  : public signal3<T_return, T_arg1, T_arg2, T_arg3, nil>
{
public:

  /** Convenience wrapper for the numbered sigc::signal3 template.
   * Like sigc::signal but the additional template parameter @e T_accumulator
   * defines the accumulator type that should be used.
   */
  template <class T_accumulator>
  class accumulated
    : public signal3<T_return, T_arg1, T_arg2, T_arg3, T_accumulator>
  {
  public:
    accumulated() {}
    accumulated(const accumulated& src)
      : signal3<T_return, T_arg1, T_arg2, T_arg3, T_accumulator>(src) {}
  };

  signal() {}

  signal(const signal& src)
    : signal3<T_return, T_arg1, T_arg2, T_arg3, nil>(src) {}

  signal(signal&& src)
    : signal3<T_return, T_arg1, T_arg2, T_arg3, nil>(std::move(src)) {}

  signal& operator=(const signal& src)
  {
    signal3<T_return, T_arg1, T_arg2, T_arg3, nil>::operator=(src);
    return *this;
  }

  signal& operator=(signal&& src)
  {
    signal3<T_return, T_arg1, T_arg2, T_arg3, nil>::operator=(std::move(src));
    return *this;
  }
};

/**
 * This specialization allow use of the  sigc::signal<R(Args...)> syntax,
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3>
class signal<T_return(T_arg1, T_arg2, T_arg3)>
  : public signal3<T_return, T_arg1, T_arg2, T_arg3, nil>
{
public:

  /** Convenience wrapper for the numbered sigc::signal3 template.
   * Like sigc::signal but the additional template parameter @e T_accumulator
   * defines the accumulator type that should be used.
   */
  template <class T_accumulator>
  class accumulated
    : public signal3<T_return, T_arg1, T_arg2, T_arg3, T_accumulator>
  {
  public:
    accumulated() {}
    accumulated(const accumulated& src)
      : signal3<T_return, T_arg1, T_arg2, T_arg3, T_accumulator>(src) {}
  };

  signal() {}

  signal(const signal& src)
    : signal3<T_return, T_arg1, T_arg2, T_arg3, nil>(src) {}

  signal(signal&& src)
    : signal3<T_return, T_arg1, T_arg2, T_arg3, nil>(std::move(src)) {}

  signal& operator=(const signal& src)
  {
    signal3<T_return, T_arg1, T_arg2, T_arg3, nil>::operator=(src);
    return *this;
  }

  signal& operator=(signal&& src)
  {
    signal3<T_return, T_arg1, T_arg2, T_arg3, nil>::operator=(std::move(src));
    return *this;
  }
};



/** Convenience wrapper for the numbered sigc::signal4 template.
 * See the base class for useful methods.
 * This is the template specialization of the unnumbered sigc::signal
 * template for 4 argument(s).
 *
 * @deprecated Please use the syntax similar to that used by std::function<>:
 * @code
 * sigc::slot<void(bool, int)> some_slot;
 * @endcode
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
class signal <T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil>
  : public signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>
{
public:

  /** Convenience wrapper for the numbered sigc::signal4 template.
   * Like sigc::signal but the additional template parameter @e T_accumulator
   * defines the accumulator type that should be used.
   */
  template <class T_accumulator>
  class accumulated
    : public signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator>
  {
  public:
    accumulated() {}
    accumulated(const accumulated& src)
      : signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator>(src) {}
  };

  signal() {}

  signal(const signal& src)
    : signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>(src) {}

  signal(signal&& src)
    : signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>(std::move(src)) {}

  signal& operator=(const signal& src)
  {
    signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>::operator=(src);
    return *this;
  }

  signal& operator=(signal&& src)
  {
    signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>::operator=(std::move(src));
    return *this;
  }
};

/**
 * This specialization allow use of the  sigc::signal<R(Args...)> syntax,
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
class signal<T_return(T_arg1, T_arg2, T_arg3, T_arg4)>
  : public signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>
{
public:

  /** Convenience wrapper for the numbered sigc::signal4 template.
   * Like sigc::signal but the additional template parameter @e T_accumulator
   * defines the accumulator type that should be used.
   */
  template <class T_accumulator>
  class accumulated
    : public signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator>
  {
  public:
    accumulated() {}
    accumulated(const accumulated& src)
      : signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_accumulator>(src) {}
  };

  signal() {}

  signal(const signal& src)
    : signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>(src) {}

  signal(signal&& src)
    : signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>(std::move(src)) {}

  signal& operator=(const signal& src)
  {
    signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>::operator=(src);
    return *this;
  }

  signal& operator=(signal&& src)
  {
    signal4<T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil>::operator=(std::move(src));
    return *this;
  }
};



/** Convenience wrapper for the numbered sigc::signal5 template.
 * See the base class for useful methods.
 * This is the template specialization of the unnumbered sigc::signal
 * template for 5 argument(s).
 *
 * @deprecated Please use the syntax similar to that used by std::function<>:
 * @code
 * sigc::slot<void(bool, int)> some_slot;
 * @endcode
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
class signal <T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil>
  : public signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>
{
public:

  /** Convenience wrapper for the numbered sigc::signal5 template.
   * Like sigc::signal but the additional template parameter @e T_accumulator
   * defines the accumulator type that should be used.
   */
  template <class T_accumulator>
  class accumulated
    : public signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator>
  {
  public:
    accumulated() {}
    accumulated(const accumulated& src)
      : signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator>(src) {}
  };

  signal() {}

  signal(const signal& src)
    : signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>(src) {}

  signal(signal&& src)
    : signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>(std::move(src)) {}

  signal& operator=(const signal& src)
  {
    signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>::operator=(src);
    return *this;
  }

  signal& operator=(signal&& src)
  {
    signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>::operator=(std::move(src));
    return *this;
  }
};

/**
 * This specialization allow use of the  sigc::signal<R(Args...)> syntax,
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
class signal<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)>
  : public signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>
{
public:

  /** Convenience wrapper for the numbered sigc::signal5 template.
   * Like sigc::signal but the additional template parameter @e T_accumulator
   * defines the accumulator type that should be used.
   */
  template <class T_accumulator>
  class accumulated
    : public signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator>
  {
  public:
    accumulated() {}
    accumulated(const accumulated& src)
      : signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_accumulator>(src) {}
  };

  signal() {}

  signal(const signal& src)
    : signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>(src) {}

  signal(signal&& src)
    : signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>(std::move(src)) {}

  signal& operator=(const signal& src)
  {
    signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>::operator=(src);
    return *this;
  }

  signal& operator=(signal&& src)
  {
    signal5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil>::operator=(std::move(src));
    return *this;
  }
};



/** Convenience wrapper for the numbered sigc::signal6 template.
 * See the base class for useful methods.
 * This is the template specialization of the unnumbered sigc::signal
 * template for 6 argument(s).
 *
 * @deprecated Please use the syntax similar to that used by std::function<>:
 * @code
 * sigc::slot<void(bool, int)> some_slot;
 * @endcode
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
class signal <T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>
  : public signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>
{
public:

  /** Convenience wrapper for the numbered sigc::signal6 template.
   * Like sigc::signal but the additional template parameter @e T_accumulator
   * defines the accumulator type that should be used.
   */
  template <class T_accumulator>
  class accumulated
    : public signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator>
  {
  public:
    accumulated() {}
    accumulated(const accumulated& src)
      : signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator>(src) {}
  };

  signal() {}

  signal(const signal& src)
    : signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>(src) {}

  signal(signal&& src)
    : signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>(std::move(src)) {}

  signal& operator=(const signal& src)
  {
    signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>::operator=(src);
    return *this;
  }

  signal& operator=(signal&& src)
  {
    signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>::operator=(std::move(src));
    return *this;
  }
};

/**
 * This specialization allow use of the  sigc::signal<R(Args...)> syntax,
 */
template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
class signal<T_return(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)>
  : public signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>
{
public:

  /** Convenience wrapper for the numbered sigc::signal6 template.
   * Like sigc::signal but the additional template parameter @e T_accumulator
   * defines the accumulator type that should be used.
   */
  template <class T_accumulator>
  class accumulated
    : public signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator>
  {
  public:
    accumulated() {}
    accumulated(const accumulated& src)
      : signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_accumulator>(src) {}
  };

  signal() {}

  signal(const signal& src)
    : signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>(src) {}

  signal(signal&& src)
    : signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>(std::move(src)) {}

  signal& operator=(const signal& src)
  {
    signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>::operator=(src);
    return *this;
  }

  signal& operator=(signal&& src)
  {
    signal6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>::operator=(std::move(src));
    return *this;
  }
};




} /* namespace sigc */

#ifdef SIGC_NIL_HAS_BEEN_PUSHED
  #undef SIGC_NIL_HAS_BEEN_PUSHED
  #pragma pop_macro("nil")
#endif

#endif /* _SIGC_SIGNAL_H_ */