circular_buffer.hh

#ifndef VTESTBED_CORE_CIRCULAR_BUFFER_HH
#define VTESTBED_CORE_CIRCULAR_BUFFER_HH

#include <algorithm>
#include <array>
#include <memory>

#include <vtestbed/base/multiple_array_iterator.hh>

namespace vtb {

    namespace core {

        template <class T>
        class Circular_buffer {

        public:
            using value_type = T;
            using pointer = value_type*;
            using const_pointer = const value_type*;
            using size_type = std::size_t;
            using offset_type = std::ptrdiff_t;
            using reference = value_type&;
            using const_reference = const value_type&;
            using iterator = vtb::base::multiple_array_iterator<pointer,2>;
            using const_iterator = vtb::base::multiple_array_iterator<const_pointer,2>;

        private:
            std::unique_ptr<T[]> _data;
            pointer _first = nullptr, _last = nullptr, _current = nullptr;
            size_type _counter = 0;

        public:

            Circular_buffer() = default;
            ~Circular_buffer() = default;

            inline
            Circular_buffer(size_type size, const value_type& value):
            _data(new T[size]{}),
            _first(_data.get()),
            _last(_first + size),
            _current(_first) {
                std::fill_n(this->data(), this->max_size(), value);
            }

            inline explicit
            Circular_buffer(size_type size):
            _data(new T[size]{}),
            _first(_data.get()),
            _last(_first + size),
            _current(_first) {}

            inline
            Circular_buffer(Circular_buffer&& rhs):
            _data{rhs._data},
            _first{rhs._first},
            _last{rhs._last},
            _current{rhs._current} {
                rhs._data = nullptr;
            }

            inline
            Circular_buffer(const Circular_buffer& rhs):
            _data{new T[rhs.max_size()]},
            _first{_data.get()},
            _last{_data.get() + rhs.max_size()},
            _current{_data.get() + (rhs._current - rhs._first)} {
                std::copy(rhs._first, rhs._last, _first);
            }

            inline Circular_buffer&
            operator=(const Circular_buffer& rhs) {
                Circular_buffer tmp(rhs);
                this->swap(tmp);
                return *this;
            }

            inline Circular_buffer&
            operator=(Circular_buffer&& rhs) {
                this->swap(rhs);
                return *this;
            }

            inline const_pointer
            data() const noexcept {
                return this->_data.get();
            }

            inline pointer
            data() noexcept {
                return this->_data.get();
            }

            inline size_type
            max_size() const noexcept {
                return this->_last - this->_first;
            }

            inline size_type
            size() const noexcept {
                return (this->middle()-this->current()) +
                    (this->current() - this->_first);
            }

            inline bool
            empty() const {
                return this->size() == 0;
            }

            inline size_type
            counter() const noexcept {
                return this->_counter;
            }

            inline const_iterator
            cbegin() const noexcept {
                return const_iterator{
                    std::make_pair(this->_current,this->middle()),
                    std::make_pair(this->_first,this->_current)
                };
            }

            inline const_iterator
            begin() const noexcept {
                return this->cbegin();
            }

            inline iterator
            begin() noexcept {
                return iterator{
                    std::make_pair(this->_current,this->middle()),
                    std::make_pair(this->_first,this->_current)
                };
            }

            inline const_iterator
            cend() const noexcept {
                return const_iterator{0,
                    std::make_pair(this->_current,this->middle()),
                    std::make_pair(this->_first,this->_current)
                };
            }

            inline const_iterator
            end() const noexcept {
                return this->cend();
            }

            inline iterator
            end() noexcept {
                return iterator{0,
                    std::make_pair(this->_current,this->middle()),
                    std::make_pair(this->_first,this->_current)
                };
            }

            inline const_pointer
            current() const noexcept {
                return this->_current;
            }

            inline pointer
            current() noexcept {
                return this->_current;
            }

            inline const_pointer
            middle() const {
                return (this->_counter == this->max_size())
                    ? this->_last : this->_current;
            }

            inline pointer
            middle() {
                return (this->_counter == this->max_size())
                    ? this->_last : this->_current;
            }

            inline value_type&
            front() noexcept {
                return *((this->_counter == this->max_size())
                    ? this->_current : this->_first);
            }

            inline const value_type&
            front() const noexcept {
                return *((this->_counter == this->max_size())
                    ? this->_current : this->_first);
            }

            inline value_type&
            back() noexcept {
                return *((this->_current == this->_first)
                    ? (this->_last-1) : (this->_current-1));
            }

            inline const value_type&
            back() const noexcept {
                return *((this->_current == this->_first)
                    ? (this->_last-1) : (this->_current-1));
            }

            inline const value_type&
            operator[](size_type i) const {
                return this->_first[i];
            }

            inline void
            record(const T& value) {
                if (this->_counter < this->max_size()) {
                    ++this->_counter;
                }
                if (_current == _last) {
                    _current = _first;
                }
                *_current = value;
                ++_current;
            }

            inline void
            record(T&& value) {
                if (this->_counter < this->max_size()) {
                    ++this->_counter;
                }
                if (_current == _last) {
                    _current = _first;
                }
                *_current = std::forward<T>(value);
                ++_current;
            }

            inline void
            resize(size_type new_size) {
                std::unique_ptr<T[]> new_data(new T[new_size]);
                size_type offset = 0;
                if (this->_data) {
                    auto first = this->_first;
                    auto last = first + std::min(new_size, this->max_size());
                    auto result = new_data.get();
                    offset = this->_current - this->_first;
                    while (first != last) {
                        *result = std::move(*first);
                        ++result;
                        ++first;
                    }
                }
                this->_data = std::move(new_data);
                this->_first = this->_data.get();
                this->_last = this->_first + new_size;
                this->_current = this->_first + std::min(offset, new_size);
                this->_counter = std::min(this->_counter, new_size);
            }

            inline void
            swap(Circular_buffer& rhs) {
                using std::swap;
                swap(this->_data, rhs._data);
                swap(this->_first, rhs._first);
                swap(this->_last, rhs._last);
                swap(this->_current, rhs._current);
                swap(this->_counter, rhs._counter);
            }

            inline void
            clear() {
                size_type n = this->max_size();
                std::fill_n(this->data(), n, value_type{});
                this->_first = this->_data.get();
                this->_last = this->_first + n;
                this->_current = this->_first;
                this->_counter = 0;
            }

        };

        template <class T>
        inline void
        swap(Circular_buffer<T>& lhs, Circular_buffer<T>& rhs) {
            lhs.swap(rhs);
        }

    }

}

#endif // vim:filetype=cpp