---

misc/cbuffer.h

Go to the documentation of this file.

#ifndef MISC_CBUFFER_H
#define MISC_CBUFFER_H

/*

  GLT OpenGL C++ Toolkit (LGPL)
  Copyright (C) 2000-2002 Nigel Stewart  

  Email: nigels.com@gmail.com   
  WWW:   http://www.nigels.com/glt/

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#include <vector>
#include <cassert>

template<class T,class A = std::allocator<T> >
class cbuffer : private std::vector<T,A>
{
private:
    typedef typename std::vector<T,A> parent;

public:

    typedef typename parent::iterator       iterator;
    typedef typename parent::const_iterator const_iterator;
    typedef typename parent::size_type      size_type;

    cbuffer(const size_type capacity = 0,const T &def = T())
    : _size(0), _full(false)
    {
            parent::reserve(capacity);
            parent::resize(capacity,def);
            _begin = _end = parent::begin();
    }
    
    ~cbuffer()
    {
    }
    
    size_type capacity() const
    {
        return parent::size();
    }

    size_type size() const
    {
        return _size;
    }

    bool empty() const
    {
        return !_full && _begin==_end;
    }

    bool full() const
    {
        return _full;
    }

    void push_front(const T &x) 
    {
        if (parent::size())
        {
            decrement(_begin);
            *_begin = x;

            if (_full)
                decrement(_end);
            else
            {
                _size++;
                if (_size==parent::size())
                    _full = true;
            }
        }
    }
    
    void push_back(const T &x)
    {
        if (parent::size())
        {
            *_end = x;
            increment((iterator &)_end);
            if (_full)
                increment((iterator &)_begin);
            else
            {
                _size++;
                if (_size==parent::size())
                    _full = true;
            }
        }
    }
    
    void pop_front()
    {
        assert(parent::size());
        assert(_size>0);
        if (_size>0)
        {
            increment((const_iterator &)_begin);
            _size--;
            _full = false;
        }
    }
    
    void pop_back()
    {
        assert(parent::size());
        assert(_size>0);
        if (_size>0)
        {
            decrement((iterator &)_end);
            _size--;
            _full = false;
        }
    }

    T &front()       
    {
        assert(parent::size());
        assert(_size>0); 
        return *_begin; 
    }

    const T &front() const 
    { 
        assert(parent::size());
        assert(_size>0); 
        return *_begin; 
    }

    T &back()
    { 
        assert(parent::size());
        assert(_size>0); 
        iterator i=_end; 
        decrement(i); 
        return *i; 
    }

    const T &back() const
    { 
        assert(parent::size());
        assert(_size>0); 
        iterator i=_end; 
        decrement((const_iterator&)i); 
        return *i; 
    }

    T &operator[](const size_type i)
    {
        if (_begin<_end)
            return *(_begin+i);
        else
        {
            const size_type s1 = parent::end()-_begin;
            if (i<s1)
                return *(_begin+i);
            else
                return *(parent::begin()+i-s1);
        }
    }

    const T &operator[](const size_type i) const
    {
        if (_begin<_end)
            return *(_begin+i);
        else
        {
            const size_type s1 = parent::end()-_begin;
            if (i<s1)
                return *(_begin+i);
            else
                return *(parent::begin()+i-s1);
        }
    }

    void leftShift()
    {
        decrement(_begin);
        decrement(_end);
    }

    void rightShift()
    {
        decrement(_begin);
        decrement(_end);
    }

    void clear()
    {
        _begin = _end = parent::begin();
        _size = 0;
        _full = false;
    }

    void swap(cbuffer<T,A> &buffer)
    {
        parent::swap(buffer);
        std::swap(_begin,buffer._begin);
        std::swap(_end  ,buffer._end  );
        std::swap(_size ,buffer._size );
        std::swap(_full ,buffer._full );
    }

    void resize(const size_type cap)
    {
        if (cap==capacity())
            return;

        cbuffer<T,A> tmp(cap);
        swap(tmp);

        iterator i = tmp._begin;
        iterator j = _begin;
        size_type k=0;
    
        for (; k<cap && k<capacity() && k<tmp.size(); j++,k++)
        {
            *j = *i;
            tmp.increment((const_iterator &)i);
        }

        _end = j;
        _size = k;
        _full = (_size==cap);
    }

private:

    iterator _begin;
    iterator _end;
    size_type        _size;
    bool             _full;
    
    void increment(const_iterator &i) const
    {
        i++;
        if (i==parent::end())
            i = parent::begin();
    }

    void decrement(const_iterator &i) const
    {
        if (i==parent::begin())
            i += parent::size()-1;
        else
            i--;
    }

    void increment(iterator &i) 
    {
        i++;
        if (i==parent::end())
            i = parent::begin();
    }

    void decrement(iterator &i) 
    {
        if (i==parent::begin())
            i += parent::size()-1;
        else
            i--;
    }
};

#endif

---