signal-signal.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
#ifndef NDN_UTIL_SIGNAL_SIGNAL_HPP
#define NDN_UTIL_SIGNAL_SIGNAL_HPP

#include "signal-connection.hpp"
#include <list>

namespace ndn {
namespace util {
namespace signal {

class DummyExtraArg;

template<typename Owner, typename ...TArgs>
class Signal : noncopyable
{
public: // API for anyone
  typedef function<void(const TArgs&...)> Handler;

  Signal();

  ~Signal();

  Connection
  connect(const Handler& handler);

  Connection
  connectSingleShot(const Handler& handler);

private: // API for owner
  bool
  isEmpty() const;

  void
  operator()(const TArgs&...args);

  void
  operator()(const TArgs&...args, const DummyExtraArg&);

  // make Owner a friend of Signal<Owner, ...> so that API for owner can be called
#if NDN_CXX_HAVE_CXX_FRIEND_TYPENAME
  friend Owner;
#elif NDN_CXX_HAVE_CXX_FRIEND_TYPENAME_WRAPPER
  template<typename T>
  struct TypeWrapper
  {
    typedef T Type;
  }; // http://stackoverflow.com/a/5608542/3729203
  friend class TypeWrapper<Owner>::Type;
#else
#  error "cannot declare Owner as friend"
#endif

private: // internal implementation
  typedef Signal<Owner, TArgs...> Self;
  struct Slot;

  typedef std::list<Slot> SlotList;

  struct Slot
  {
    Handler handler;

    shared_ptr<function<void()>> disconnect;
  };

  SlotList m_slots;

  bool m_isExecuting;

  typename SlotList::iterator m_currentSlot;

  void
  disconnect(typename SlotList::iterator it);
};

template<typename Owner, typename ...TArgs>
Signal<Owner, TArgs...>::Signal()
  : m_isExecuting(false)
{
}

template<typename Owner, typename ...TArgs>
Signal<Owner, TArgs...>::~Signal()
{
  BOOST_ASSERT(!m_isExecuting);
}

template<typename Owner, typename ...TArgs>
Connection
Signal<Owner, TArgs...>::connect(const Handler& handler)
{
  typename SlotList::iterator it = m_slots.insert(m_slots.end(), {handler, nullptr});
  it->disconnect = make_shared<function<void()>>(bind(&Self::disconnect, this, it));

  return signal::Connection(weak_ptr<function<void()>>(it->disconnect));
}

template<typename Owner, typename ...TArgs>
Connection
Signal<Owner, TArgs...>::connectSingleShot(const Handler& handler)
{
  typename SlotList::iterator it = m_slots.insert(m_slots.end(), {nullptr, nullptr});
  it->disconnect = make_shared<function<void()>>(bind(&Self::disconnect, this, it));
  signal::Connection conn(weak_ptr<function<void()>>(it->disconnect));

  it->handler = [conn, handler] (const TArgs&... args) mutable {
    handler(args...);
    conn.disconnect();
  };

  return conn;
}

template<typename Owner, typename ...TArgs>
void
Signal<Owner, TArgs...>::disconnect(typename SlotList::iterator it)
{
  // 'it' could be const_iterator, but gcc 4.6 doesn't support std::list::erase(const_iterator)

  if (m_isExecuting) {
    // during signal emission, only the currently executing handler can be disconnected
    BOOST_ASSERT_MSG(it == m_currentSlot, "cannot disconnect another handler from a handler");

    // this serves to indicate that the current slot needs to be erased from the list
    // after it finishes executing; we cannot do it here because of bug #2333
    m_currentSlot = m_slots.end();

    // expire all weak_ptrs, to prevent double disconnections
    it->disconnect.reset();
  }
  else {
    m_slots.erase(it);
  }
}

template<typename Owner, typename ...TArgs>
bool
Signal<Owner, TArgs...>::isEmpty() const
{
  return !m_isExecuting && m_slots.empty();
}

template<typename Owner, typename ...TArgs>
void
Signal<Owner, TArgs...>::operator()(const TArgs&... args)
{
  BOOST_ASSERT_MSG(!m_isExecuting, "cannot emit signal from a handler");

  if (m_slots.empty()) {
    return;
  }

  auto it = m_slots.begin();
  auto last = std::prev(m_slots.end());
  m_isExecuting = true;

  try {
    bool isLast = false;
    while (!isLast) {
      m_currentSlot = it;
      isLast = it == last;

      m_currentSlot->handler(args...);

      if (m_currentSlot == m_slots.end())
        it = m_slots.erase(it);
      else
        ++it;
    }
  }
  catch (...) {
    m_isExecuting = false;
    throw;
  }

  m_isExecuting = false;
}

template<typename Owner, typename ...TArgs>
void
Signal<Owner, TArgs...>::operator()(const TArgs&... args, const DummyExtraArg&)
{
  this->operator()(args...);
}

} // namespace signal

// expose as ndn::util::Signal
using signal::Signal;

} // namespace util
} // namespace ndn

#endif // NDN_UTIL_SIGNAL_SIGNAL_HPP