CircularBuffer.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/common/CircularBuffer.h#5 $
// Fennel is a library of data storage and processing components.
// Copyright (C) 2005-2009 The Eigenbase Project
// Copyright (C) 2005-2009 SQLstream, Inc.
// Copyright (C) 2005-2009 LucidEra, Inc.
// Portions Copyright (C) 1999-2009 John V. Sichi
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 of the License, or (at your option)
// any later version approved by The Eigenbase Project.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef Fennel_CircularBuffer_Included
#define Fennel_CircularBuffer_Included

FENNEL_BEGIN_NAMESPACE

template <class T>
class CircularBuffer
{
    std::vector<T> buffer;

    uint nEntries;

    uint nFreeEntries;

    uint firstPos;

    bool readOnly;

    void init(uint nEntriesInit)
    {
        nEntries = nEntriesInit;
        buffer.resize(nEntries);
        clear();
    }

public:
    explicit CircularBuffer()
    {
        init(0);
    }

    explicit CircularBuffer(uint nEntriesInit)
    {
        init(nEntriesInit);
    }

    void clear()
    {
        firstPos = 0;
        nFreeEntries = nEntries;
        readOnly = false;
    }

    void resize(uint nEntriesInit)
    {
        init(nEntriesInit);
    }

    uint size()
    {
        return nEntries;
    }

    bool empty()
    {
        return (nFreeEntries == nEntries);
    }

    bool spaceAvailable()
    {
        return (nFreeEntries != 0);
    }

    uint nFreeSpace()
    {
        return nFreeEntries;
    }

    uint getFirstPos()
    {
        assert(!empty());
        return firstPos;
    }

    uint getLastPos()
    {
        return nEntries - nFreeEntries + firstPos - 1;
    }

    T &reference_back()
    {
        assert(!empty());
        uint lastEntry = getLastPos() % nEntries;
        return buffer[lastEntry];
    }

    void push_back(T &newEntry)
    {
        assert(!readOnly);
        assert(nFreeEntries > 0);
        uint freeEntry = (nEntries - nFreeEntries + firstPos) % nEntries;
        buffer[freeEntry] = newEntry;
        nFreeEntries--;
    }

    T &reference_front()
    {
        assert(!empty());
        return buffer[firstPos % nEntries];
    }

    void pop_front()
    {
        assert(!empty());
        firstPos++;
        nFreeEntries++;
    }

    T & operator [] (uint pos)
    {
        return buffer[pos % nEntries];
    }

    bool isReadOnly()
    {
        return readOnly;
    }

    void setReadOnly()
    {
        readOnly = true;
    }
};

template <class T>
class CircularBufferIter
{
    CircularBuffer<T> *pCircularBuffer;

    uint currPos;

public:

    explicit CircularBufferIter(CircularBuffer<T> *pCircularBufferInit)
    {
        pCircularBuffer = pCircularBufferInit;
        reset();
    }

    void reset()
    {
        currPos = 0;
    }

    void operator ++ ()
    {
        assert(!pCircularBuffer->empty());
        currPos++;
    }

    T & operator * ()
    {
        assert(!pCircularBuffer->empty());
        assert(
            currPos >= pCircularBuffer->getFirstPos() &&
            currPos <= pCircularBuffer->getLastPos());
        return (*pCircularBuffer)[currPos];
    }

    bool end()
    {
        return
            (pCircularBuffer->empty() ||
                currPos > pCircularBuffer->getLastPos());
    }

    bool done()
    {
        return end() && pCircularBuffer->isReadOnly();
    }

    uint getCurrPos()
    {
        return currPos;
    }

    void setCurrPos(uint pos)
    {
        currPos = pos;
    }

    void removeFront()
    {
        pCircularBuffer->pop_front();
    }
};

FENNEL_END_NAMESPACE

#endif

// End CircularBuffer.h

---