ringbuffer.h

Go to the documentation of this file.

#pragma once

#include "common/util.h"

namespace TwinE {

template<typename TYPE, size_t SIZE = 64u>
class RingBuffer {
protected:
    size_t _size;
    size_t _front;
    size_t _back;
    TYPE _buffer[SIZE];

public:
    using value_type = TYPE;

    RingBuffer() : _size(0u), _front(0u), _back(SIZE - 1u) {
    }

    class iterator {
    private:
        RingBuffer *_ringBuffer;
        size_t _idx;

    public:
        iterator(RingBuffer *ringBuffer, size_t idx) : _ringBuffer(ringBuffer), _idx(idx) {
        }

        inline const TYPE &operator*() const {
            return _ringBuffer->_buffer[_idx % _ringBuffer->capacity()];
        }

        inline TYPE &operator*() {
            return _ringBuffer->_buffer[_idx % _ringBuffer->capacity()];
        }

        inline const TYPE &operator()() const {
            return _ringBuffer->_buffer[_idx % _ringBuffer->capacity()];
        }

        inline TYPE &operator()() {
            return _ringBuffer->_buffer[_idx % _ringBuffer->capacity()];
        }

        iterator &operator++() {
            ++_idx;
            return *this;
        }

        inline bool operator!=(const iterator &rhs) const {
            return _ringBuffer != rhs._ringBuffer || _idx != rhs._idx;
        }

        inline bool operator==(const iterator &rhs) const {
            return _ringBuffer == rhs._ringBuffer && _idx == rhs._idx;
        }

        inline const TYPE *operator->() const {
            return &_ringBuffer->_buffer[_idx % _ringBuffer->capacity()];
        }
    };

    iterator begin() {
        return iterator(this, _front);
    }

    iterator end() {
        return iterator(this, _front + _size);
    }

    iterator begin() const {
        return iterator(const_cast<RingBuffer *>(this), _front);
    }

    iterator end() const {
        return iterator(const_cast<RingBuffer *>(this), _front + _size);
    }

    inline size_t size() const {
        return _size;
    }

    constexpr size_t capacity() const {
        return SIZE;
    }

    inline bool empty() const {
        return _size == 0;
    }

    const TYPE &front() const {
        return _buffer[_front];
    }

    TYPE &front() {
        return _buffer[_front];
    }

    const TYPE &back() const {
        return _buffer[_back];
    }

    TYPE &back() {
        return _buffer[_back];
    }

    void clear() {
        _front = 0u;
        _back = SIZE - 1u;
        _size = 0u;
    }

    void push_back(const TYPE &x) {
        _back = (_back + 1u) % SIZE;
        if (_size == SIZE) {
            _front = (_front + 1u) % SIZE;
        } else {
            ++_size;
        }
        _buffer[_back] = x;
    }

    template<typename... _Args>
    void emplace_back(_Args &&...args) {
        _back = (_back + 1u) % SIZE;
        if (_size == SIZE) {
            _front = (_front + 1u) % SIZE;
        } else {
            ++_size;
        }
        _buffer[_back] = Common::move(TYPE{Common::forward<_Args>(args)...});
    }

    void pop() {
        if (_size == 0) {
            return;
        }
        --_size;
        _front = (_front + 1u) % SIZE;
    }

    void erase_back(const size_t n) {
        if (n >= _size) {
            clear();
            return;
        }
        _size -= n;
        _back = (_front + _size - 1u) % SIZE;
    }

    void erase_front(const size_t n) {
        if (n >= _size) {
            clear();
            return;
        }
        _front = (_front + n) % SIZE;
        _size -= n;
    }

    inline TYPE &operator[](size_t i) {
        return _buffer[(_front + i) % SIZE];
    }

    inline const TYPE &operator[](size_t i) const {
        return _buffer[(_front + i) % SIZE];
    }
};

} // namespace TwinE