ptr_dispatcher.hh

Go to the documentation of this file.

#ifndef PTR_DISPATCHER_HH
#define PTR_DISPATCHER_HH

#include <pthread.h>
#include <deque>
#include <boost/atomic.hpp>

/**
 * \author cpellegrino
 */

class ptrDispatcher
{
  std::deque<void*> m_queue;

  pthread_mutex_t m_mutex;

  pthread_cond_t   m_cond;

  boost::atomic<bool> m_status;

 public:

  ptrDispatcher()
    :
    m_status(true)
  {
    pthread_mutex_init(&m_mutex, 0);
    pthread_cond_init (&m_cond,  0);
  }

  ~ptrDispatcher()
  {
    close();
    pthread_mutex_destroy(&m_mutex);
    pthread_cond_destroy(&m_cond);
  }

  void close()
  {
    m_status = false;
    lock();
    signal();
    unlock();
  }

  void signal()
  {
    pthread_cond_signal(&m_cond);
  }

  void lock()
  {
    pthread_mutex_lock(&m_mutex);
  }

  void unlock()
  {
    pthread_mutex_unlock(&m_mutex);
  }

  void* get_nolock()
  {
    if (m_queue.empty() || !m_status)
    {
      return 0;
    }

    void* pointer = m_queue.front();
    m_queue.pop_front();
    return pointer;
  }

  void* get()
  {
    if (!m_status)
    {
      return 0;
    }

    lock();
    wait();

    void* pointer = 0;

    if (m_queue.size())
    {
      pointer = m_queue.front();
      m_queue.pop_front();
    }

    unlock();
    return pointer;
  }

  void put_nolock(void* pointer)
  {
    if (m_status)
    {
      m_queue.push_back(pointer);
    }
  }

  void put(void* pointer)
  {
    if (m_status)
    {
      lock();
      m_queue.push_back(pointer);
      signal();
      unlock();
    }
  }

 private:

  void wait()
  {
    while (m_queue.empty() && m_status)
    {
      if (pthread_cond_wait(&m_cond, &m_mutex) == EINVAL)
      {
        break;
      }
    }
  }

};

#endif // PTR_DISPATCHER_HH