circularbuffer.h

Go to the documentation of this file.

/*  circularbuffer.h - N producers/consumers circular buffer
    Copyright (C) 2001-2004 Mark Weaver
    Written by Mark Weaver <mark@npsl.co.uk>

    Part of the Open-Win32 library.
    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., 59 Temple Place - Suite 330,
    Boston, MA  02111-1307, USA.
*/

#ifndef OW32_circularbuffer_h
#define OW32_circularbuffer_h

#include <OW32/SyncObjects.h>
#include <cstddef> // for size_t

namespace OW32
{

template <class T>
class CCircularBuffer
{
public:
    CCircularBuffer(size_t queueSize) :
        m_head(0),
        m_tail(0),
        m_semEmpty(static_cast<LONG>(queueSize), static_cast<LONG>(queueSize)),
        m_semFull(static_cast<LONG>(queueSize), 0L),
        m_evBreak(TRUE),
        m_fBreak(false),
        m_queueSize(queueSize)
    {
        m_buf = new T[m_queueSize];
    }

    ~CCircularBuffer()
    {
        delete [] m_buf;
    }

    bool isBroken()
    {
        return m_fBreak;
    }

    void Break()
    {
        m_fBreak = true;
        m_evBreak.Set();
    }

    void ResetBreak()
    {
        m_fBreak = false;
        m_evBreak.Reset();
    }

    bool putElement(const T& el, DWORD nTimeout = INFINITE)
    {
        /* wait for a space */
        HANDLE wait_space[2] = { m_semEmpty, m_evBreak };
        
        switch (WaitForMultipleObjects(2, wait_space, FALSE, nTimeout)) {
        case WAIT_OBJECT_0:
            if (m_fBreak)
                return false;
            break;
        case WAIT_TIMEOUT:
            return false;
        default:
            return false;
        }

        /* put the element, with protection for the tail */
        {
            CSingleLock access_tail(m_csTail);
            m_buf[m_tail] = el;
            m_tail = (m_tail+1)%m_queueSize;
        }

        /* release one waiting consumer */
        m_semFull.Release(1);
        return true;
    }

    bool getElement(T& el, DWORD nTimeout = INFINITE)
    {
        /* wait for an element */
        HANDLE wait_space[2] = { m_semFull, m_evBreak };

        switch (WaitForMultipleObjects(2, wait_space, FALSE, nTimeout)) {
        case WAIT_OBJECT_0:
            if (m_fBreak)
                return false;
            break;
        case WAIT_TIMEOUT:
            return false;
        default:
            return false;
        }

        /* get the element, with protection for the head */
        {
            CSingleLock access_head(m_csHead);
            el = m_buf[m_head];
            m_head = (m_head+1)%m_queueSize;
        }

        /* release one waiting producer */
        m_semEmpty.Release(1);
        return true;
    }

private:
    size_t              m_head, m_tail, m_queueSize;
    T*                  m_buf;
    CSemaphore          m_semEmpty, m_semFull;
    CCriticalSection    m_csHead, m_csTail;

    // event and predicate for aborting waiters
    CEvent              m_evBreak;
    bool                m_fBreak;

    // no copy or assign
    CCircularBuffer& operator=(const CCircularBuffer&);
    CCircularBuffer(const CCircularBuffer&);

};

}; // namespace OW32

#endif // OW32_circularbuffer_h

---