circular_buffer.h

/*
 * This file is part of SPORE.
 *
 * Copyright (C) 2016, the SPORE team (see AUTHORS).
 *
 * SPORE 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 2 of the License, or
 * (at your option) any later version.
 *
 * SPORE 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 with SPORE.  If not, see <http://www.gnu.org/licenses/>.
 *
 * For more information see: https://github.com/IGITUGraz/spore-nest-module
 *
 * File:   circular_buffer.h
 * Author: Kappel
 *
 * Created on November 3, 2016, 6:23 PM
 */

#ifndef CIRCULAR_BUFFER_H
#define CIRCULAR_BUFFER_H


namespace spore
{

template<typename T>
class CircularBuffer
{
public:

    class const_iterator
    {
    public:

        const_iterator(const const_iterator& src)
        : ptr_(src.ptr_),
        begin_(src.begin_),
        end_(src.end_)
        {
        }

        inline
        const_iterator& operator++()
        {
            if (++ptr_ == end_)
                ptr_ = begin_;
            return *this;
        }

        inline
        const_iterator& operator--()
        {
            if (ptr_ == begin_)
                ptr_ = end_ - 1;
            else
                ptr_--;
            return *this;
        }

        inline
        T const& operator*() const
        {
            return *ptr_;
        }

    private:
        friend class CircularBuffer;

        const_iterator(size_t offs, T const* mem, size_t size)
        : ptr_(&mem[offs]),
        begin_(mem),
        end_(&mem[size])
        {
        }

        T const* ptr_;
        T const* begin_;
        T const* end_;
    };

    CircularBuffer()
    : mem_(0),
    size_(0)
    {
    }

    CircularBuffer(const CircularBuffer& src)
    : mem_(0),
    size_(src.size_)
    {
        if (src.size_ > 0)
        {
            mem_ = new T[size_];
            for (size_t i = 0; i < size_; i++)
                mem_[i] = src.mem_[i];
        }
    }

    ~CircularBuffer()
    {
        delete mem_;
    }

    void resize(size_t new_size, T v)
    {
        delete mem_;
        mem_ = 0;
        if (new_size > 0)
        {
            mem_ = new T[new_size];
            for (size_t i = 0; i < new_size; i++)
                mem_[i] = v;
        }
        size_ = new_size;
    }

    T &operator[](size_t at)
    {
        assert(mem_);
        return mem_[get_index(at)];
    }

    const_iterator get(size_t at) const
    {
        assert(mem_);
        return const_iterator(get_index(at), mem_, size_);
    }

    size_t size() const
    {
        return size_;
    }

private:

    inline
    size_t get_index(size_t at) const
    {
        return at % size_;
    }

    T* mem_;
    size_t size_;
};

}

#endif /* CIRCULAR_BUFFER_H */