UT/UT_RingBuffer.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Andrew Clinton
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT_RingBuffer.h ( UT Library, C++)
 *
 * COMMENTS:
 */

#ifndef __UT_RingBuffer__
#define __UT_RingBuffer__

#include "UT_API.h"
#include "UT_RingBufferRaw.h"

/// A UT_RingBuffer is an indexable queue.  The buffer uses indices
/// that represent the insertion order of items in the buffer.  The
/// buffer may contain "holes", which have no associated data but 
/// still have an order number.
template <class utPtr>
class UT_RingBuffer {
public:
     UT_RingBuffer() {}
     UT_RingBuffer(int capacity) : myBuf(capacity) {}
    ~UT_RingBuffer() {}

    /// Null-padded insertion.  If the id of the incoming object is 
    /// greater than the next order number that would be assigned 
    /// by push(), holes are created in the buffer.
    void         insert(int id, utPtr data) { myBuf.insert(id, (void *)data); }
    void         remove(int id) { myBuf.remove(id); }

    /// Pop the first element off the head of the list, moving the first entry
    /// to the next element.
    utPtr       popFirst()
                {
                    utPtr       data = front();
                    pop();
                    return data;
                }
    
    /// Insert the data into the buffer, and return the order number that
    /// it is assigned.
    int          push(utPtr data) { return myBuf.push((void *)data); }

    /// Pop a single element from the start of the buffer
    void         pop() { myBuf.pop(); }

    /// Pop the next "number" elements from the buffer
    void         pop(int number) { myBuf.pop(number); }
   
    int          entries() const        { return myBuf.entries(); }
    int          peakUsage() const      { return myBuf.peakUsage(); }
   
    /// operator [] is the bounds checked version of the operator.  The
    /// id is the order number of the object being indexed.
    utPtr        operator[](int id) const { return (utPtr)myBuf[id]; }
    utPtr        operator()(int id) const { return (utPtr)myBuf(id); }

    /// In order to iterate over the contents of the ring buffer
    ///         for (i = rbuf.frontId(); i <= rbuf.backId(); i++)
    ///                 element = rbuf(i);
    /// The backId is *inclusive*!!!  There shouldn't be holes in the array.

    utPtr        front() const { return (utPtr)myBuf.front(); }
    int          frontId() const { return myBuf.frontId(); }
    utPtr        back() const { return (utPtr)myBuf.back(); }
    int          backId() const { return myBuf.backId(); }

    void         display() const { myBuf.display(); }
   
private:
    UT_RingBufferRaw    myBuf;
};

#endif

---