circular_buffer.h

Go to the documentation of this file.

#pragma once
#include <stddef.h>
#include "../intlimits.h"
 
template <typename index_t = uint_fast8_t, index_t size = 16>
class CircularIndex {
public:
    static constexpr bool size_is_power2 = !(size & (size - 1));
 
    static_assert(size <= std::numeric_limits<index_t>::max() / 2,
        "index_t is too small for the requested size");
 
    constexpr inline CircularIndex()
        : tail(0)
        , head(0) {}
 
    inline bool empty() const {
        return tail == head;
    }
 
    inline bool full() const {
        return count() == size;
    }
 
    inline void reset() {
        head = tail;
    }
 
    inline void push() {
        head = next(head);
    }
 
    inline void pop() {
        tail = next(tail);
    }
 
    inline index_t front() const {
        return mask(tail);
    }
 
    inline index_t back() const {
        return mask(head);
    }
 
    inline index_t count() const {
        if constexpr (size_is_power2)
            return head - tail;
        else {
            return head >= tail
                ? (head - tail)
                : (size * 2 + head) - tail;
        }
    }
 
protected:
    index_t tail; 
    index_t head; 
 
    static index_t mask(index_t cursor) { return cursor % size; }
 
    static index_t next(index_t cursor) {
        // note: the modulo can be avoided if size is a power of two: we can do this
        // relying on the optimizer eliding the following check at compile time.
        if constexpr (size_is_power2)
            return (cursor + 1);
        else
            return (cursor + 1) % (size * 2);
    }
};
 
template <typename T = uint8_t, typename index_t = uint_fast8_t, size_t size = 16>
class CircularBuffer {
public:
    inline bool empty() const {
        return index.empty();
    }
 
    bool full() const {
        return index.full();
    }
 
    inline void reset() {
        index.reset();
    }
 
    bool push(T elem) {
        if (full())
            return false;
        data[index.back()] = elem;
        index.push();
        return true;
    }
 
    inline T front() const {
        return data[index.front()];
    }
 
    bool pop(T &elem) {
        if (empty())
            return false;
        elem = front();
        index.pop();
        return true;
    }
 
    index_t count() const {
        return index.count();
    }
 
protected:
    T data[size]; 
    CircularIndex<index_t, size> index; 
};