circular_buffer.hpp

Go to the documentation of this file.

#pragma once

namespace auxiliary
{
    template <typename T>
    class circular_buffer
    {
        typedef T           value_type;
        typedef T&          reference;
        typedef const T&    const_reference;
        typedef size_t      size_type;
    public:
        explicit circular_buffer(const size_type n): buffer_(n), size_(n), contents_size_(0), head_(0), tail_(0) {}

        reference next()
        {
            assert(contents_size_ == size_);
            inc_head();
            inc_tail();
            return buffer_[tail_];
        }

        void push_back(const value_type& item)
        {
            if (contents_size_ == 0) {
                buffer_[tail_] = item;
                contents_size_++;
            } else {
                inc_tail();
                buffer_[tail_] = item;

                if (contents_size_ == size_)
                    inc_head();
                else
                    contents_size_++;
            }

            buffer_[tail_] = item;
        }

        inline reference front() { return buffer_[head_]; }

        inline const_reference front() const { return buffer_[head_]; }

        inline reference back() { return buffer_[tail_]; }

        inline const_reference back() const { return buffer_[tail_]; }

        inline const_reference operator[] (size_type i) const
        {
            assert(i < size_);
            return buffer_[(head_ + i) % size_];
        }

        inline reference operator[] (size_type i)
        {
            assert(i < size_);
            return buffer_[(head_ + i) % size_];
        }

        void clear()
        {
            head_ = tail_ = contents_size_ = 0;
            buffer_.clear();
        }

        inline size_type size() const { return size_; }

    private:
        void inc_head()
        {
            ++head_;
            if (head_ == size_) head_ = 0;
        }

        void inc_tail()
        {
            ++tail_;
            if (tail_ == size_) tail_ = 0;
        }

    private:
        std::vector<T>  buffer_;        
        size_type       size_;          
        size_type       contents_size_; 
        size_type       head_;          
        size_type       tail_;          
    };
}