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 <cstdint> // for std::uint8_t
#include <algorithm> // for std::copy
#include <memory>
#include <cassert>


namespace gnash {

//
class SimpleBuffer {

public:

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

        SimpleBuffer(SimpleBuffer&&) = default;

        SimpleBuffer(const SimpleBuffer& b) = delete;
        SimpleBuffer& operator= (const SimpleBuffer& b) = delete;

        SimpleBuffer& operator= (SimpleBuffer&&) = default;


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

        size_t size() const { return _size; }

        size_t capacity() const { return _capacity; }

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

        const std::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);

                std::unique_ptr<std::uint8_t[]> tmp;
                tmp.swap(_data);
                
                _data.reset(new std::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 std::uint8_t* newData =
            reinterpret_cast<const std::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 std::uint8_t b)
        {
                resize(_size + 1);
                _data[_size - 1] = b;
        }

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

        //
        void appendNetworkLong(const std::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 std::uint8_t* incomingData = buf.data();
                append(incomingData, incomingDataSize);
        }

private:
        size_t _size;
        size_t _capacity;

        std::unique_ptr<std::uint8_t[]> _data;
};


}       // namespace gnash

#endif // GNASH_SIMPLEBUFFER_H