wefts_queue.h

Go to the documentation of this file.

/*
   wefts_queue.h
   Waitable template FIFO structure.

   $Id: wefts_queue.h,v 1.6 2004/08/14 21:38:35 jonnymind Exp $
---------------------------------------------
   Begin      : 2003-08-03 17:50
   Author     : Giancarlo Niccolai

   Last modified because:

*/

/**************************************************************************
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU Library General Public License as       *
*   published by the Free Software Foundation; either version 2.1 of the  *
*   License, or (at your option) any later version.                       *
***************************************************************************/


#ifndef WT_QUEUE_H
#define WT_QUEUE_H

#include <wefts_fastcond.h>
#include <list>

namespace Wefts {

template <class T>
class Queue
{
private:
   void p_waitForFree() {
      while ( m_list.size() >= m_maxLen )
         m_cond.wait();
   }

   void p_waitForFull() {
      while ( m_list.size() == 0 )
         m_cond.wait();
   }

protected:
   FastCondition m_cond;
   unsigned long m_maxLen;
   int m_size;
   std::list<T> m_list;

public:
   Queue( unsigned int maxLen = 0):
      m_size( 0 ),
      m_maxLen( 0 )
   {}

   bool push( T elem, const bool wait=false)
   {
      m_cond.lock();
      if ( m_maxLen > 0 && m_size >= m_maxLen )
      {
         if ( wait ) {
            // this is for compilers that canno expand loops inline
            p_waitForFree();
         }
         else {
            m_cond.unlock();
            return false;
         }
      }
      m_size++;
      m_list.push_back( elem );
      m_cond.signal();
      m_cond.unlock();
      return true;
   }


   bool pop( T &elem, const bool wait=true)
   {
      m_cond.lock();
      if ( m_size == 0 )
      {
         if ( wait ) {
            // this is for compilers that canno expand loops inline
            p_waitForFull();
         }
         else {
            m_cond.unlock();
            return false;
         }
      }
      m_size --;
      elem = m_list.front();
      m_list.pop_front();
      m_cond.signal();
      m_cond.unlock();
      return true;
   }

   bool empty() const
   {
      Queue<T> *Self = const_cast<Queue<T>*>(this);
      Self->m_cond.lock();
      bool res = (m_size == 0);
      Self->m_cond.unlock();
      return res;
   }
   
   int size() const 
   {
      Queue<T> *Self = const_cast<Queue<T>*>(this);
      Self->m_cond.lock();
      int res = m_size;
      Self->m_cond.unlock();
      return res;
   }
};


/*
template<class T> class Queue< T* >: private Queue< void*>
{
public:
   typedef Queue< void *> Base;
   
   Queue( int maxsize=0 ): Base( maxsize ) {}
   
   bool push( T* elem, const bool wait=false)
   {
      return Base::push( elem, wait );    
   }
   
   bool pop( T* &elem, const bool wait = false )
   {
      return Base::pop( elem, wait );
   }

}; 
*/

}

#endif
/* end of wefts_queue.h */

---