UT/UT_RingBufferRaw.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_RingBufferRaw.h ( UT Library, C++)
 *
 * COMMENTS:
 */

#ifndef __UT_RingBufferRaw__
#define __UT_RingBufferRaw__

#include "UT_API.h"

/// A UT_RingBufferRaw 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.
class UT_API UT_RingBufferRaw {
public:
     UT_RingBufferRaw();
     UT_RingBufferRaw(int capacity);
    ~UT_RingBufferRaw();

    /// 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, void *data);
    void         remove(int id);
    
    /// Insert the data into the buffer, and return the order number that
    /// it is assigned.
    int          push(void *data);

    /// Pop a single element from the start of the buffer
    void         pop();

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

    void        *front() const { return myData[myFirst]; }
    int          frontId() const { return myFirstId; }
    void        *back() const { return myData[myLast]; }
    int          backId() const { return myLastId; }

    void         display() const;
   
private:
    void         checkResize(int number);
    int          idIndex(int id) const
                 { return (id - myFirstId + myFirst) % myCapacity; }
    void         removeNulls();

private:
    void        **myData;
    int           myCapacity;
    int           myFirst;
    int           myLast;

    // Order numbers increase monotonically as data is added to 
    // the buffer.
    int           myFirstId;
    int           myLastId;

    int           myPeak;
};

#endif

---