circularBuffer.hpp

#pragma once
 
#include "arrayLike.hpp"
#include "sizable.hpp"
#include <type_traits>
 
namespace z {
namespace core {
template <typename TYPE, unsigned int LEN>
class circularIterator {
    const TYPE *ptr;
    int offset;
 
public:
    circularIterator(const TYPE *buffer, int index) noexcept : ptr(buffer), offset(index) {}

    circularIterator operator++() noexcept {
        ++offset;
        return *this;
    }

    bool operator!=(const circularIterator &other) const noexcept {
        return offset != other.offset;
    }

    const TYPE &operator*() const noexcept {
        return ptr[offset % LEN];
    }
};

template <typename TYPE, unsigned int LEN>
class circularBuffer : public sizable, public arrayLike<const TYPE &, circularIterator<TYPE, LEN>> {
    TYPE data[LEN];  // The data to store
    int counter = 0; // The current index. This will always be between 0 and LEN.
    int total = 0;   // The total number of items in the buffer. This will never exceed LEN.
 
    static_assert(LEN > 0, "Buffer must have more than zero elements.");
 
public:
    circularBuffer() noexcept {}

    template <typename... ARGS>
    circularBuffer(const ARGS &...args) noexcept {
        populate(args...);
    }

    circularBuffer(TYPE default_value) noexcept {
        for (int i = 0; i < LEN; ++i) {
            data[i] = default_value;
        }
    }
 
    size_t size() const noexcept override {
        return sizeof(TYPE) * LEN;
    }
 
    int length() const noexcept override {
        return LEN;
    }

    const TYPE &at(const int index) const noexcept override {
        return data[index % LEN];
    }
 
    // Get a reference to an element from the buffer. This is used when we ARE modifying it.
    // The compiler knows the difference and will use this function only when needed.

    TYPE &at(const int index) noexcept {
        return data[index % LEN];
    }

    void append(const TYPE value) noexcept {
        data[counter] = value;
        counter = (counter + 1) % LEN;
        if (total < LEN) {
            ++total;
        }
    }

    int index() const noexcept {
        return counter;
    }

    TYPE &current() noexcept {
        return data[counter];
    }

    int count() const noexcept {
        return total;
    }

    void prev() noexcept {
        counter = (counter + LEN - 1) % LEN;
    }

    void next() noexcept {
        counter = (counter + 1) % LEN;
    }
 
    circularIterator<TYPE, LEN> begin() const noexcept override {
        return circularIterator<TYPE, LEN>(data, counter + LEN + LEN - total);
    }
 
    circularIterator<TYPE, LEN> end() const noexcept override {
        return circularIterator<TYPE, LEN>(data, counter + LEN + LEN);
    }

    template <typename... ARGS>
    void populate(const TYPE &first, const ARGS &...args) noexcept {
        append(first);
        populate(args...);
    }

    void populate(const TYPE &arg) noexcept {
        append(arg);
    }

    TYPE minimum() const noexcept {
        static_assert(std::is_arithmetic<TYPE>::value, "circularBuffer::minimum() is only defined for arithmetic types.");
 
        TYPE value = data[0];
        for (int i = 1; i < LEN; ++i) {
            if (data[i] < value) {
                value = data[i];
            }
        }
        return value;
    }

    TYPE maximum() const noexcept {
        static_assert(std::is_arithmetic<TYPE>::value, "circularBuffer::maximum() is only defined for arithmetic types.");
 
        TYPE value = data[0];
        for (int i = 1; i < LEN; ++i) {
            if (data[i] > value) {
                value = data[i];
            }
        }
        return value;
    }

    double average() const noexcept {
        static_assert(std::is_arithmetic<TYPE>::value, "circularBuffer::average() is only defined for arithmetic types.");
 
        double avg = 0.0;
        for (int i = 0; i < LEN; ++i) {
            avg += (double)data[i] / (double)LEN;
        }
        return avg;
    }
};
} // namespace core
} // namespace z