ringbuffer.hpp

#pragma once
 
/* #include "log.hpp" */
#include "../util/util.hpp"
 
#include <vector>
#include <iterator>
#include <algorithm>
#include <concepts>
 
namespace gz {
    template<std::swappable T>
    class RingBuffer {
        public:
            RingBuffer(size_t size=10);
 
            struct Iterator {
                public:
                    Iterator(const RingBuffer<T>& b, size_t index) : b(b), ptr(const_cast<T*>(&b.buffer.at(index))) {}
                    Iterator(const Iterator& other) : b(other.b), ptr(other.ptr) {}
                // Needed for std::input_iterator
                    using value_type = T;
                    T& operator*() const { return *ptr; }
                    Iterator& operator=(const Iterator& other) {
                        b = other.b;
                        ptr = other.ptr;
                        return this;
                    }
                    Iterator& operator++() {
                        if (ptr == &*b.buffer.begin()) { ptr = const_cast<T*>(&*b.buffer.rbegin()); }
                        else { ptr--; }
                        return *this;
                    }
                    Iterator operator++(int) {
                        auto copy = *this;
                        if (ptr == &*b.buffer.begin()) { ptr = const_cast<T*>(&*b.buffer.rbegin()); }
                        else { ptr--; }
                        return copy;
                    }
                    friend int operator-(Iterator lhs, Iterator rhs) {
                        return lhs.getCurrentIndex() - rhs.getCurrentIndex();
                    }
                // Needed for std::forward_iterator
                    Iterator() : ptr(nullptr) {};
                    bool operator==(const Iterator& other) const {
                        return this->ptr == other.ptr;
                    }
                // Needed for std::bidirectional_iterator
                    Iterator& operator--() {
                        if (ptr == &*b.buffer.rbegin()) { ptr = const_cast<T*>(&*b.buffer.begin()); }
                        else { ptr++; }
                        return *this;
                    }
                    Iterator operator--(int) {
                        auto copy = *this;
                        if (ptr == &*b.buffer.rbegin()) { ptr = const_cast<T*>(&*b.buffer.begin()); }
                        else { ptr++; }
                        return copy;
                    }
                // Not needed )
                    /* friend Iterator operator+(Iterator lhs, int i) { */
                    /*     return Iterator(lhs.b, &lhs.b.buffer[lhs.getValidIndex(lhs.getCurrentIndex() + i)]); */
                    /* } */
                    /* friend Iterator operator-(Iterator lhs, int i) { */
                    /*     return Iterator(lhs.b, &lhs.b.buffer[lhs.getValidIndex(lhs.getCurrentIndex() - i)]); */
                    /* } */
                    /* friend Iterator operator+(int i, Iterator rhs) { */
                    /*     return Iterator(rhs.b, &rhs.b.buffer[rhs.getValidIndex(rhs.getCurrentIndex() + i)]); */
                    /* } */
                    /* Iterator& operator+=(int i) { */
                    /*     ptr = &b.buffer[getValidIndex(getCurrentIndex() + i)]; */
                    /*     return this; */
                    /* } */
                    /* Iterator& operator-=(int i) { */
                    /*     ptr = &b.buffer[getValidIndex(getCurrentIndex() - i)]; */
                    /*     return this; */
 
                    /* } */
                    /* bool operator!=(const Iterator& other) const { */
                    /*     return this->ptr != other.ptr; */
                    /* } */
                    std::string to_string() const {
                        return "Element: " + std::to_string(*ptr) + ", Index: " + std::to_string(getCurrentIndex()) + ", Pointer: " + std::to_string(reinterpret_cast<long>(ptr));
                    }
                private:
                    size_t getCurrentIndex() const {
                        return reinterpret_cast<long>(ptr - &*b.buffer.begin());
                    }
                    T* ptr;
                    const RingBuffer<T>& b;
            };
            void push_back(T& t);
            void push_back(T&& t) { push_back(t); };
            void emplace_back(T&& t);
 
            const Iterator cbegin() const { return Iterator(*this, writeIndex); }
            const Iterator cend() const { return Iterator(*this, util::getIncrementedIndex(writeIndex, buffer.size())); }
            const Iterator crbegin() const { return Iterator(*this, util::getIncrementedIndex(writeIndex + 1, buffer.size())); }
            const Iterator crend() const { return Iterator(*this, util::getIncrementedIndex(writeIndex, buffer.size())); }
 
            const Iterator begin() { return Iterator(*this, writeIndex); }
            const Iterator end() { return Iterator(*this, util::getIncrementedIndex(writeIndex, buffer.size())); }
            const Iterator rbegin() { return Iterator(*this, util::getIncrementedIndex(writeIndex + 1, buffer.size())); }
            const Iterator rend() { return Iterator(*this, util::getIncrementedIndex(writeIndex, buffer.size())); }
 
            void resize(const size_t size);
 
            size_t capacity() const { return vectorCapacity - 1; }
            size_t size() const { return buffer.size() - 1; }
 
        private:
            size_t writeIndex;  
            std::vector<T> buffer;
            size_t vectorCapacity;
    };
 
    template<std::swappable T>
    RingBuffer<T>::RingBuffer(size_t capacity) {
        buffer.reserve(capacity + 1);
        buffer.resize(1);
        vectorCapacity = capacity + 1;
 
        writeIndex = 0;
    }
 
    template<std::swappable T>
    void RingBuffer<T>::resize(size_t size) {
        if (size + 1 > buffer.capacity()) {  // when growing
            // point writeIndex to separator
            util::incrementIndex(writeIndex, buffer.size());
            // separator element becomes first element -> vector grows while inserting elements
            std::rotate(buffer.begin(), buffer.begin() + writeIndex, buffer.end());
            buffer.reserve(size + 1);
            writeIndex = buffer.size() - 1;
        } 
        else if (size + 1 < buffer.size()) {  // when shrinking
            // point writeIndex to separator
            util::incrementIndex(writeIndex, buffer.size());
            // separator becomes last element in smaller vector -> resize cuts oldest elements
            std::rotate(buffer.begin(), buffer.begin() + util::getValidIndex(static_cast<int>(writeIndex - size), buffer.size()), buffer.end());
            buffer.resize(size + 1);
            writeIndex = util::getValidIndex(static_cast<int>(buffer.size() - 2), buffer.size());
        }
        vectorCapacity = size + 1;
 
    }
 
    template<std::swappable T>
    void RingBuffer<T>::push_back(T& t) {
        util::incrementIndex(writeIndex, vectorCapacity);
        if (buffer.size() < vectorCapacity) {
            buffer.push_back(t); 
        }
        else {
            buffer[writeIndex] = t;
        }
    }
    template<std::swappable T>
    void RingBuffer<T>::emplace_back(T&& t) {
        util::incrementIndex(writeIndex, vectorCapacity);
        if (buffer.size() < vectorCapacity) {
            buffer.emplace_back(std::move(t)); 
        }
        else {
            buffer[writeIndex] = std::move(t);
        }
    }
}