root/trunk/cbear.berlios.de/range/circular_buffer.hpp

#ifndef CBEAR_BERLIOS_DE_RANGE_CIRCULAR_BUFFER_HPP_INCLUDED
#define CBEAR_BERLIOS_DE_RANGE_CIRCULAR_BUFFER_HPP_INCLUDED

#include <cbear.berlios.de/range/size_type.hpp>

namespace cbear_berlios_de
{
namespace range
{

template<class T, ::std::size_t L>
class circular_buffer
{
public:
        typedef T value_type;
        typedef value_type &reference;
        typedef value_type const &const_reference;
        typedef ::std::size_t size_type;
        typedef ::std::ptrdiff_t difference_type;       

        circular_buffer(): 
                b(0),
                s(0)
        {
        }

        reference at(size_type i)
        {
                return this->x[this->index(i)];
        }

        const_reference at(size_type i) const
        {
                return this->x[this->index(i)];
        }

        reference operator[](size_type i)
        {
                return this->at(i);
        }

        const_reference operator[](size_type i) const
        {
                return this->at(i);
        }

        void push_back(const_reference v)
        {
                this->at(this->s) = v;
                if(this->s < L)
                {
                        ++this->s;
                }
                else
                {
                        this->b = (this->b + 1) % L;
                }
        }

        size_type size() const
        {
                return this->s;
        }

        void clear()
        {
                this->b = 0;
                this->s = 0;
        }

private:
        value_type x[L];
        size_type b;
        size_type s;    
        size_type index(size_type i) const
        {
                return (this->b + i) % L;
        }
};

}
}

#endif