circular_buffer.hpp

Go to the documentation of this file.

/*
Copyright (c) 2025 acrion innovations GmbH
Authors: Stefan Zipproth, s.zipproth@acrion.ch
 
This file is part of Cbeam, see https://github.com/acrion/cbeam and https://cbeam.org
 
Cbeam is offered under a commercial and under the AGPL license.
For commercial licensing, contact us at https://acrion.ch/sales. For AGPL licensing, see below.
 
AGPL licensing:
 
Cbeam is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
 
Cbeam 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 Affero General Public License for more details.
 
You should have received a copy of the GNU Affero General Public License
along with Cbeam. If not, see <https://www.gnu.org/licenses/>.
*/
 
#pragma once
 
#include <cbeam/error/out_of_range.hpp>
 
#include <cstddef> // for std::size_t
 
#include <array>     // for std::array
#include <utility>   // for std::forward
 
namespace cbeam::container
{
    template <typename T, std::size_t S>
    class circular_buffer
    {
    public:
        using value_type      = T;
        using size_type       = std::size_t;
        using reference       = value_type&;
        using const_reference = const value_type&;
        using iterator        = typename std::array<T, S>::iterator;
        using const_iterator  = typename std::array<T, S>::const_iterator;

        circular_buffer() = default;

        auto begin() noexcept
        {
            return _buffer.begin();
        }

        auto end() noexcept
        {
            return _full ? _buffer.end() : _buffer.begin() + _i;
        }

        std::size_t size() const
        {
            return _full ? S : _i;
        }

        std::size_t max_size() const
        {
            return S;
        }

        void push_back(const T& t)
        {
            _buffer[_i] = t;
            _i          = (_i + 1) % S;
            if (_i == 0)
            {
                _full = true;
            }
        }
 
        bool empty() const noexcept { return !_full && _i == 0; }
 
        void clear() noexcept
        {
            _i    = 0;
            _full = false;
        }

        template <typename... Args>
        void emplace_back(Args&&... args)
        {
            _buffer[_i] = T(std::forward<Args>(args)...);
            _i          = (_i + 1) % S;
            if (_i == 0)
            {
                _full = true;
            }
        }

        reference at(size_type pos)
        {
            if (pos >= size())
            {
                throw cbeam::error::out_of_range("Position out of range");
            }
 
            return _buffer[(pos + (_full ? _i : 0)) % S];
        }

        const_reference at(size_type pos) const
        {
            if (pos >= size())
            {
                throw cbeam::error::out_of_range("Position out of range");
            }
 
            return _buffer[(pos + (_full ? _i : 0)) % S];
        }

        reference operator[](size_type pos)
        {
            return _buffer[(pos + (_full ? _i : 0)) % S];
        }

        const_reference operator[](size_type pos) const
        {
            return _buffer[(pos + (_full ? _i : 0)) % S];
        }

        reference front()
        {
            return _buffer[_full ? _i : 0];
        }

        const_reference front() const
        {
            return _buffer[_full ? _i : 0];
        }

        reference back()
        {
            return _buffer[(_i + S - 1) % S];
        }

        const_reference back() const
        {
            return _buffer[(_i + S - 1) % S];
        }
 
    private:
        std::array<T, S> _buffer;      
        std::size_t      _i{0};        
        bool             _full{false}; 
    };
}