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.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all 
 * copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NON INFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 * File: ring_buffer.hpp
 * Author Mohammed Boujemaoui Boulaghmoudi on 02/10/18.
 */

#ifndef EDSP_RING_BUFFER_HPP
#define EDSP_RING_BUFFER_HPP

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

namespace edsp { inline namespace types {

    template <typename T, typename Allocator = std::allocator<T>>
    class 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::vector<T, Allocator> container_type;

        constexpr ring_buffer()                       = default;
        constexpr ring_buffer(const ring_buffer&)     = default;
        constexpr ring_buffer(ring_buffer&&) noexcept = default;
        constexpr ring_buffer& operator=(const ring_buffer&) = default;
        constexpr ring_buffer& operator=(ring_buffer&&) noexcept = default;

        explicit ring_buffer(size_type N) {
            buffer_.resize(N);
            ring_ = edsp::ring_span<T>(std::begin(buffer_), std::end(buffer_));
        }

        ring_buffer(size_type N, const value_type& value) {
            buffer_.resize(N);
            ring_ = edsp::ring_span<T>(std::begin(buffer_), std::end(buffer_), std::begin(buffer_), N);
            std::fill(begin(), end(), value);
        }

        ~ring_buffer() = default;

        void resize(size_type size) {
            buffer_.resize(size);
            ring_ = edsp::ring_span<T>(std::begin(buffer_), std::end(buffer_));
        }

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

        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 %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();
        }

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

        constexpr size_type max_size() const {
            return buffer_.max_size();
        }

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

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

        constexpr 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_RING_BUFFER_HPP