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