RingBuffer.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_RINGBUFFER_HXX_
#define _UTILS_RINGBUFFER_HXX_
 
#include <new>
#include "utils/macros.h"
 
template <typename T> class RingBuffer
{
public:
    static inline RingBuffer *create(size_t size)
    {
        RingBuffer *ring_buffer =
            (RingBuffer*)malloc(sizeof(RingBuffer) + (size * sizeof(T)));
        /* placement new allows for runtime ring buffer size */
        new (ring_buffer) RingBuffer(size);
        
        return ring_buffer;
    }
 
    void destroy()
    {
        free(this);
    }
 
    size_t put(const T *buf, size_t items)
    {
        size_t inserted = items < (_size - count) ? items : (_size - count);
        
        for (size_t i = 0; i < inserted; ++i)
        {
            data[writeIndex++] = buf[i];
            
            if (writeIndex == _size)
            {
                writeIndex = 0;
            }
        }
        
        count += inserted;
        return inserted;
    }
    
    size_t get(T *buf, size_t items)
    {
        size_t removed = items < count ? items : count;
        
        for (size_t i = 0; i < removed; ++i)
        {
            buf[i] = data[readIndex++];
            
            if (readIndex == _size)
            {
                readIndex = 0;
            }
        }
        
        count -= removed;
        return removed;
    }
 
    size_t data_read_pointer(T **buf)
    {
        size_t result = size - readIndex;
        if (count < result)
        {
            result = count;
        }
        *buf = data + readIndex;
        return result;
    }
 
    size_t data_write_pointer(T **buf)
    {
        size_t result = size - writeIndex;
        if (space() < result)
        {
            result = space();
        }
        *buf = data + writeIndex;
        return result;
    }
 
    size_t consume(size_t items)
    {
        if (items > count)
        {
            items = count;
        }
        size_t consumed = items;
        count -= items;
        if ((readIndex + items) >= size)
        {
            items -= (size - readIndex);
            readIndex = 0;
        }
        readIndex += items;
 
        // Try to align the buffer so that we have the most available space to
        // write.
        if (!count)
        {
            readIndex = writeIndex = 0;
        }
 
        return consumed;
    }
 
    size_t advance(size_t items)
    {
        if (items > space())
        {
            items = space();
        }
        size_t added = items;
        count += items;
        if ((writeIndex + items) >= size)
        {
            items -= (size - writeIndex);
            writeIndex = 0;
        }
        writeIndex += items;
 
        return added;
    }
 
    size_t items()
    {
        return count;
    }
    
    size_t size()
    {
        return _size;
    }
    
    size_t space()
    {
        return _size - count;
    }
    
private:
    RingBuffer(size_t size)
        : _size(size),
          count(0),
          readIndex(0),
          writeIndex(0)
    {
    }
 
    RingBuffer();
    
    ~RingBuffer();
 
    DISALLOW_COPY_AND_ASSIGN(RingBuffer);
    
    size_t _size;
    
    size_t count;
    
    size_t readIndex;
    
    size_t writeIndex;
    
    T data[];
};
 
#endif /* _UTILS_RINGBUFFER_HXX_ */