shared_list.hpp

#ifndef HAVE_TOM__SHARED_LIST_HPP
#define HAVE_TOM__SHARED_LIST_HPP
 
#include <tom-util/defines.hpp>
 
#include <boost/thread/barrier.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/xtime.hpp>
#include <list>
 
/*
  The idea:
     Structure where data T's can be FIFO'd safely across threads.
     Structure is in one of several states:
    Read/Write    -  writable / readable - Reads block if no-data available
    Read Only     -  readable ONLY - if empty() then done!
*/
//TOM_NAMESPACE_BEGIN;
namespace tom {
 
  template <typename T>
  class TOM_UTIL_API shared_list
  {
  public:
    typedef T      value_type;
    
    shared_list() : m_read_only( false ) { }
    virtual ~shared_list() { }
 
    bool 
    empty();
 
    void
    set_read_only();
 
    bool
    read_only();
 
    void
    pop_front();
 
    // fast fetch/pop w/o the need to check empty()
    bool
    pop_front( T & );
 
    void
    push_back( const T & );
 
    T &
    front();
 
    const T &
    front() const;
 
  private:
    typedef boost::mutex::scoped_lock    lock;
 
    bool m_read_only;
    mutable boost::condition m_buffer_empty;
    mutable boost::condition m_buffer_ready;
    mutable boost::mutex m_monitor;
 
//    mutable std::list<T> m_list;
    mutable std::list<T> m_list;
  };
 
  template <typename T>
  void
  shared_list<T>::pop_front()
  {
    lock l( m_monitor );
 
    // if we are not read-only and empty, block until new data arrives
    if ( ( ! m_read_only ) && m_list.empty() )
      m_buffer_ready.wait(l);      
 
    if ( ! m_list.empty() )
      m_list.pop_front();
 
  }
  // fast fetch/pop w/o the need to check empty()
  template <typename T>
  bool
  shared_list<T>::pop_front( T &v )
  {
    lock l( m_monitor );
 
    // if we are not read-only and empty, block until new data arrives
    if ( ( ! m_read_only ) && m_list.empty() )
    {
      m_buffer_empty.notify_one();
      m_buffer_ready.wait(l); // and wait for him to produce
    }
    if ( ! m_list.empty() )
    {
      v = m_list.front();
      m_list.pop_front();
      return true;
    }
    else
      return false;
  }
  template <typename T>
  void
  shared_list<T>::push_back( const T &v )
  {
    // important thing if starvation happens!
    boost::thread::thread::yield();
 
    lock l( m_monitor );
 
    // no pushing if we are read-only
    if ( m_read_only )
      return;
 
 
    // if buffer is full we should wait on a condition of emptiness
    if ( m_list.size() > 1000 ) // lets put the size into the template
    {
      // wait for the buffer to empty
      m_buffer_empty.wait(l);  // this unlocks the mutex/monitor
    }
    // if we are empty, we need to notify any 
    // blocked threads waiting to read
    bool notify = m_list.empty() ? true : false;
 
    // push the data on list
    m_list.push_back( v );
 
    // if it was empty notify we are ready!
    if ( notify )
      m_buffer_ready.notify_one();
  }
 
  template <typename T>
  T &
  shared_list<T>::front()
  {
    lock l( m_monitor );
 
    // if we are not read-only and empty, block until new data arrives
    if ( (! m_read_only ) && m_list.empty() )
      m_buffer_ready.wait(l);
 
    return m_list.front();
  }
 
  template <typename T>
  const T &
  shared_list<T>::front() const
  {
    lock l( m_monitor );
 
    // if we are not read-only and empty, block until new data arrives
    if ( (! m_read_only) && m_list.empty() )
      m_buffer_ready.wait(l);
 
    return m_list.front();
  }
  template <typename T>
  bool 
  shared_list<T>::empty()
  {
    lock l( m_monitor );
 
    // if we are not read-only and empty, block until new data arrives
    if ( ( ! m_read_only ) && m_list.empty() )
      m_buffer_ready.wait(l);
 
    return m_list.empty();
  }
  template <typename T>
  void
  shared_list<T>::set_read_only()
  {
    lock l( m_monitor );
    m_read_only = true;
    m_buffer_ready.notify_one();
  }
 
//TOM_NAMESPACE_END;
} // end tom namespace
 
#endif