fixed_ring_buffer.hpp

Go to the documentation of this file.

/*
* eDSP, A cross-platform Digital Signal Processing library written in modern C++.
* Copyright (C) 2018 Mohammed Boujemaoui Boulaghmoudi, All rights reserved.
*
* This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along width
* this program.  If not, see <http://www.gnu.org/licenses/>
*
* File: fixed_fixed_ring_buffer.hpp
* Author: Mohammed Boujemaoui
* Date: 07/10/18
*/

#ifndef EDSP_FIXED_RING_BUFFER_HPP
#define EDSP_FIXED_RING_BUFFER_HPP

#include <edsp/meta/unused.hpp>
#include <edsp/types/ring_span.hpp>
#include <array>

namespace edsp { inline namespace types {

    template <typename T, std::size_t MaxSize>
    class fixed_ring_buffer {
    public:
        typedef typename ring_span<T>::value_type value_type;
        typedef typename ring_span<T>::pointer pointer;
        typedef typename std::add_const_t<pointer> const_pointer;
        typedef typename ring_span<value_type>::reference reference;
        typedef typename ring_span<value_type>::const_reference const_reference;
        typedef typename ring_span<value_type>::iterator iterator;
        typedef typename ring_span<value_type>::const_iterator const_iterator;
        typedef typename ring_span<value_type>::reverse_iterator reverse_iterator;
        typedef typename ring_span<value_type>::const_reverse_iterator const_reverse_iterator;
        typedef typename ring_span<value_type>::size_type size_type;
        typedef std::ptrdiff_t difference_type;
        typedef std::array<T, MaxSize> container_type;

        fixed_ring_buffer()                             = default;
        fixed_ring_buffer(const fixed_ring_buffer&)     = default;
        fixed_ring_buffer(fixed_ring_buffer&&) noexcept = default;
        fixed_ring_buffer& operator=(const fixed_ring_buffer&) = default;
        fixed_ring_buffer& operator=(fixed_ring_buffer&&) noexcept = default;

        ~fixed_ring_buffer() = default;

        void clear() {
            ring_ = edsp::ring_span<T>(std::begin(buffer_), std::end(buffer_));
        }

        iterator begin() noexcept {
            return ring_.begin();
        }

        const_iterator begin() const noexcept {
            return ring_.begin();
        }

        iterator end() noexcept {
            return ring_.end();
        }

        const_iterator end() const noexcept {
            return ring_.end();
        }

        /*
         * @brief Returns a read/write iterator that points to the first
         *
         * Iteration is done in reverse element order.
         * @returns Iterator pointing to the first element.
         */
        reverse_iterator rbegin() noexcept {
            return ring_.rbegin();
        }

        const_reverse_iterator rbegin() const noexcept {
            return ring_.rbegin();
        }

        reverse_iterator rend() noexcept {
            return ring_.rend();
        }

        /*
         * @brief Returns a read-only iterator that points to the last
         * element in the %fixed_ring_buffer.
         *
         * Iteration is done in reverse element order.
         * @returns Iterator pointing to the last element.
         */
        const_reverse_iterator rend() const noexcept {
            return ring_.rend();
        }

        const_iterator cbegin() const noexcept {
            return ring_.cbegin();
        }

        const_iterator cend() const noexcept {
            return ring_.cend();
        }

        const_reverse_iterator crbegin() const noexcept {
            return ring_.crbegin();
        }

        const_reverse_iterator crend() const noexcept {
            return ring_.crend();
        }

        size_type size() const {
            return ring_.size();
        }

        size_type max_size() const {
            return MaxSize;
        }

        bool empty() const {
            return ring_.empty();
        }

        bool full() const {
            return ring_.full();
        }

        size_type capacity() const {
            return ring_.capacity();
        }

        reference operator[](std::size_t i) {
            return ring_[i];
        }

        const_reference operator[](std::size_t i) const {
            return ring_[i];
        }

        reference at(std::size_t i) {
            return ring_.at(i);
        }

        const_reference at(std::size_t i) const {
            return ring_.at(i);
        }

        reference front() {
            return ring_.front();
        }

        const_reference front() const {
            return ring_.front();
        }

        reference back() {
            return ring_.back();
        }

        const_reference back() const {
            return ring_.back();
        }

        template <typename... Args>
        void emplace_front(Args... arg) {
            ring_.emplace_front(arg...);
        }

        template <typename... Args>
        void emplace_back(Args... arg) {
            ring_.emplace_back(arg...);
        }

        void push_back(const value_type& item) {
            ring_.push_back(item);
        }

        void pop_front() {
            ring_.pop_front();
        }

        void pop_back() {
            ring_.pop_back();
        }

        const container_type& buffer() const {
            return buffer_;
        }

        const_pointer* data() const {
            return buffer_.data();
        }

    private:
        container_type buffer_{};
        edsp::ring_span<T> ring_{std::begin(buffer_), std::end(buffer_)};
    };

}} // namespace edsp::types

#endif //EDSP_FIXED_RING_BUFFER_HPP