SimpleBuffer.h

Go to the documentation of this file.

// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc
// 
// This program 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 3 of the License, or
// (at your option) any later version.
// 
// This program 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 this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef GNASH_SIMPLEBUFFER_H
#define GNASH_SIMPLEBUFFER_H


#include <boost/cstdint.hpp> // for boost::uint8_t
#include <algorithm> // for std::copy
#include <boost/scoped_array.hpp>
#include <cassert>


namespace gnash {

//
class SimpleBuffer {

public:

        //
        SimpleBuffer(size_t capacity=0)
                :
                _size(0),
                _capacity(capacity)
        {
                if ( _capacity )
                {
                        _data.reset(new boost::uint8_t[_capacity]);
                }
        }

        //
        SimpleBuffer(const SimpleBuffer& b)
                :
                _size(b._size),
                _capacity(b._size)
        {
                if ( _size )
                {
                        _data.reset(new boost::uint8_t[_size]);
                        std::copy(b.data(), b.data()+b.size(), _data.get());
                }
        }

        //
        SimpleBuffer& operator= (const SimpleBuffer& b)
        {
                if ( this != &b )  // don't waste time on self-assignment
                {
                        resize(0); // shouldn't deallocate memory
                        append(b);
                }
                return *this;
        }

        bool empty() const { return _size==0; }

        size_t size() const { return _size; }

        size_t capacity() const { return _capacity; }

        boost::uint8_t* data() { return _data.get(); }

        const boost::uint8_t* data() const { return _data.get(); }

        void resize(size_t newSize)
        {
                reserve(newSize); // will set capacity
                _size = newSize;
        }

        void reserve(size_t newCapacity)
        {
                if ( _capacity >= newCapacity ) return;

                // TODO: use smalles power of 2 bigger then newCapacity
                _capacity = std::max(newCapacity, _capacity*2);

                boost::scoped_array<boost::uint8_t> tmp;
                tmp.swap(_data);
                
                _data.reset(new boost::uint8_t[_capacity]);

                if ( tmp.get() )
                {
                        if ( _size ) std::copy(tmp.get(), tmp.get()+_size, _data.get());
                }
        }

        //
        void append(const void* inData, size_t size)
        {
                const boost::uint8_t* newData = 
            reinterpret_cast<const boost::uint8_t*>(inData);
                size_t curSize = _size;
                resize(curSize+size);
                std::copy(newData, newData+size, _data.get()+curSize);
                assert(_size == curSize+size);
        }

        //
        void appendByte(const boost::uint8_t b)
        {
                resize(_size + 1);
                _data[_size - 1] = b;
        }

        //
        void appendNetworkShort(const boost::uint16_t s)
        {
                resize(_size + 2);
                _data[_size - 2] = s >> 8;
                _data[_size - 1] = s & 0xff;
        }

        //
        void appendNetworkLong(const boost::uint32_t l)
        {
                resize(_size + 4);
                _data[_size - 4] = l >> 24;
                _data[_size - 3] = (l >> 16) & 0xff;
                _data[_size - 2] = (l >> 8) & 0xff;
                _data[_size - 1] = l & 0xff;
        }

        //
        void append(const SimpleBuffer& buf)
        {
                size_t incomingDataSize = buf.size();
                const boost::uint8_t* incomingData = buf.data();
                append(incomingData, incomingDataSize);
        }

private:
        size_t _size;
        size_t _capacity;

        boost::scoped_array<boost::uint8_t> _data;
};


}       // namespace gnash

#endif // GNASH_SIMPLEBUFFER_H