Public API Reference

csplugincommon/sndsys/queue.h

Go to the documentation of this file.

/*
    Copyright (C) 2004 by Andrew Mann

    This library 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 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/


#ifndef SNDSYS_QUEUE_H
#define SNDSYS_QUEUE_H


#include "csutil/thread.h"

namespace CS
{
 namespace SndSys
 {

  typedef enum
  {
    QUEUE_SUCCESS    =  0,

    QUEUE_ERR_CLOSED = -1,

    QUEUE_ERR_NOMEM  = -2,

    QUEUE_ERR_DUPE   = -3
  } QueueErrorType;


  // Advance declaration of class QueueIterator
  template<typename T> class QueueIterator;

  template<typename T>
  class QEntry
  {       
  public:
    T * data;
    QEntry *next, *prev;
  };    

  template<typename T>
  class Queue
  {     
  public:

    Queue() :
        m_pHead(0), m_pTail(0), m_EntryCount(0), m_bClosed(false), m_bDupeCheck(false)
    { 
      // A recursive mutex is used so that the duplicate entry check can hold a
      // lock m_EntryCount of 2
      m_pAccessMutex = csMutex::Create(true);
      m_pEntryReadyCondition = csCondition::Create();
    } 

    ~Queue()
    {
      Clear(); 
    }

    void Clear()
    { 
      QEntry<T> *del;
      Lock(); 
      while (m_pHead)
      {
        del=m_pHead; 
        m_pHead=m_pHead->next;
        delete del;
      }
      m_pTail=0;

      // Wake all waiting threads, queue is cleared
      m_pEntryReadyCondition->Signal(true);
      Unlock();
    }

    QueueErrorType QueueEntry(T* pData)
    {
      Lock();

      if (m_bClosed) return QUEUE_ERR_CLOSED;

      if (m_bDupeCheck && Find(pData))
      {
        Unlock();
        return QUEUE_ERR_DUPE;
      }

      QEntry<T> *pNewEntry= new QEntry<T>();
      if (!pNewEntry)
      {
        Unlock();
        return QUEUE_ERR_NOMEM;
      }
      pNewEntry->data=pData;
      pNewEntry->prev=m_pTail;
      pNewEntry->next=0;

      if (!m_pTail)
        m_pHead=pNewEntry;
      else
        m_pTail->next=pNewEntry;
      m_pTail=pNewEntry;


      // Signal one waiting thread to wake up
      m_pEntryReadyCondition->Signal();

      Unlock();
      return QUEUE_SUCCESS;
    }

    T * DequeueEntry(bool bWait=false)
    {
      QEntry<T> *pRemoved;
      T* pData=0;

      Lock();

      // Wait for an entry to be available if specified
      if (!m_pHead && bWait)
        m_pEntryReadyCondition->Wait(m_pAccessMutex,0);

      // Remove the m_pHead entry from the queue, shift
      //  the head pointer to the next entry
      if (m_pHead)
      {
        
        pRemoved=m_pHead;
        m_pHead=m_pHead->next;
        // Make sure the Next and Previous linked list pointers
        //  remain valid.
        if (m_pHead)
          m_pHead->prev=0;
        else
          m_pTail=0;
        pData=pRemoved->data;
        // Delete the entry wrapper object
        delete pRemoved;
      }
      Unlock();
      return pData;
    }

    size_t Length() { return m_EntryCount; }

    bool Find(T *data)
    {
      Lock();
      QEntry<T> *cur=m_pHead;
      while (cur)
      {
        if (((cur->data)) == (data))
        {
          Unlock();
          return true;
        }
        cur=cur->next;
      }
      Unlock();
      return false;
    }

    void SetClosed(bool Closed)
    {
      Lock();
      m_bClosed=Closed;
      Unlock();
    }

    bool GetClosed()
    {
      bool Closed;
      Lock();
      Closed=m_bClosed;
      Unlock();
      return Closed;
    }

    void SetDupecheck(bool Check)
    {
      Lock();
      m_bDupeCheck=Check;
      Unlock();
    }

    bool GetDupecheck()
    {
      bool val;
      Lock();
      val=m_bClosed;
      Unlock();
      return val;
    }

    QueueIterator<T>* GetIterator()
    {
      return new QueueIterator<T>(this);
    }

  protected:

    inline void Lock()
    {
      m_pAccessMutex->LockWait();
    }

    inline void Unlock()
    {
      m_pAccessMutex->Release();
    }

  protected:
    QEntry<T> *m_pHead;
    QEntry<T> *m_pTail;
    size_t m_EntryCount;
    volatile bool m_bClosed;
    volatile bool m_bDupeCheck;

    csRef<csMutex> m_pAccessMutex;
    csRef<csCondition> m_pEntryReadyCondition;


    friend class QueueIterator<T>;
  };



  template<typename T>
  class QueueIterator
  {
  public:
    QueueIterator(Queue<T> *queue)
    {
      q=queue;
      current=0;
      q->Lock();
    }

    ~QueueIterator()
    {
      q->Unlock();
    }

    T * First()
    {
      current=q->m_pHead;
      return current;
    }

    T * Last()
    {
      current=q->m_pTail;
      return current;
    }

    T *Next()
    {
      if (current) current=current->next;
      return current;
    }


    T * Prev()
    {
      if (current) current=current->prev;
      return current;
    }

  protected:
    QEntry<T> *current;
    Queue<T> *q;
  };



 }
 // END namespace CS::SndSys
}
// END namespace CS



#endif // #ifndef SNDSYS_QUEUE_H

---