AsyncThreadSigCSignal.h

Go to the documentation of this file.

 
#ifndef ASYNC_THREAD_SIGC_SIGNAL_INCLUDED
#define ASYNC_THREAD_SIGC_SIGNAL_INCLUDED
 
 
/****************************************************************************
 *
 * System Includes
 *
 ****************************************************************************/
 
#include <sigc++/sigc++.h>
 
 
/****************************************************************************
 *
 * Project Includes
 *
 ****************************************************************************/
 
#include <AsyncApplication.h>
#include <AsyncMutex.h>
#include <AsyncTaskRunner.h>
 
 
/****************************************************************************
 *
 * Local Includes
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Forward declarations
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Namespace
 *
 ****************************************************************************/
 
namespace Async
{
 
 
/****************************************************************************
 *
 * Forward declarations of classes inside of the declared namespace
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Defines & typedefs
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Exported Global Variables
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Class definitions
 *
 ****************************************************************************/
 
template <typename T_ret, typename... Args>
class ThreadSigCSignal
{
  public:
    typedef T_ret                                   result_type;
    typedef sigc::slot<T_ret, Args...>              slot_type;
    typedef typename sigc::slot_list<slot_type>     slot_list_type;
    typedef typename sigc::signal<T_ret, Args...>   signal_type;
    typedef typename signal_type::iterator          iterator;
    typedef typename signal_type::const_iterator    const_iterator;
 
    enum Mode { NON_SYNCHRONOUS, SYNCHRONOUS };
 
    ThreadSigCSignal(Mode mode=NON_SYNCHRONOUS) : m_mode(mode) {}
 
    ThreadSigCSignal(const ThreadSigCSignal&) = delete;
 
    ~ThreadSigCSignal(void)
    {
      m_runner.cancel();
      std::lock_guard<Async::Mutex> lk(m_mu);
      m_sig.clear();
    }
 
    ThreadSigCSignal& operator=(const ThreadSigCSignal&) = delete;
 
    iterator connect(const slot_type& slt)
    {
      return m_sig.connect(slt);
    }
 
    template <typename... T>
    result_type emit(T&&... args)
    {
      return handleSignal(std::forward<T>(args)...);
    }
 
    template <typename... T>
    result_type emit_reverse(T&&... args)
    {
      return handleReverseSignal(std::forward<T>(args)...);
    }
 
    template <typename... T>
    result_type operator()(T&&... args)
    {
      return handleSignal(std::forward<T>(args)...);
    }
 
    slot_type make_slot(void)
    {
      return sigc::mem_fun(*this, &ThreadSigCSignal::handleSignal<Args...>);
    }
 
    slot_list_type slots(void)
    {
      return m_sig.slots();
    }
 
    const slot_list_type slots(void) const
    {
      return m_sig.slots();
    }
 
  private:
    sigc::signal<T_ret, Args...>    m_sig;
    const Mode                      m_mode;
    Async::Mutex                    m_mu;
    Async::TaskRunner               m_runner;
 
    template <typename... T>
    result_type handleSignal(T&&... args)
    {
      if (m_mode == SYNCHRONOUS)
      {
        std::lock_guard<Async::Mutex> lk(m_mu);
        return m_sig.emit(std::forward<T>(args)...);
      }
      else
      {
        m_runner(&signal_type::emit, &m_sig, std::forward<T>(args)...);
      }
      return result_type();
    }
 
    template <typename... T>
    result_type handleReverseSignal(T&&... args)
    {
      if (m_mode == SYNCHRONOUS)
      {
        std::lock_guard<Async::Mutex> lk(m_mu);
        return m_sig.emit_reverse(std::forward<T>(args)...);
      }
      else
      {
        m_runner(&signal_type::emit_reverse, &m_sig, std::forward<T>(args)...);
      }
      return result_type();
    }
};  /* class ThreadSigCSignal */
 
 
} /* namespace */
 
#endif /* ASYNC_THREAD_SIGC_SIGNAL_INCLUDED */
 
/*
 * This file has not been truncated
 */