buffer.h

/* Copyright (c) 2007-2009, Stefan Eilemann <eile@equalizergraphics.com> 
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *  
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef EQBASE_BUFFER_H
#define EQBASE_BUFFER_H

#include <eq/base/nonCopyable.h> // base class
#include <eq/base/debug.h>       // EQASSERT macro

namespace eq
{
namespace base
{
    template< typename T >
    class Buffer
    {
    public:
        Buffer() : _data(0), _size(0), _maxSize(0) {}

        ~Buffer() { clear(); }

        void clear() 
            { if( _data ) free( _data ); _data=0; _size=0; _maxSize=0; }

        Buffer( Buffer& from )
            {
                _data = from._data; _size = from._size; _maxSize =from._maxSize;
                from._data = 0; from._size = 0; from._maxSize = 0;
            }

        const Buffer& operator = ( Buffer& from )
            {
                replace( from._data, from._size );
                return *this;
            }

        T&       operator[]( const size_t position )
            { EQASSERT( _size > position ); return _data[ position ]; }
        const T& operator[]( const size_t position) const
            { EQASSERT( _size > position ); return _data[ position ]; }

        void resize( const uint64_t newSize )
            { 
                _size = newSize;
                if( newSize <= _maxSize )
                    return;
                
                const size_t nBytes = newSize * sizeof( T );
                if( _data )
                    _data = static_cast< T* >( realloc( _data, nBytes ));
                else
                    _data = static_cast< T* >( malloc( nBytes ));
                
                _maxSize = newSize;
            }

        void reserve( const uint64_t newSize )
            { 
                if( newSize <= _maxSize )
                    return;

                if( _data )
                    free( _data );
                
                _data = static_cast< T* >( malloc( newSize * sizeof( T )));
                _maxSize = _size;
            }

        void append( const T* addData, const uint64_t addSize )
            {
                EQASSERT( addData );
                EQASSERT( addSize );

                const uint64_t oldSize = _size;
                resize( oldSize + addSize );
                memcpy( _data + oldSize, addData, addSize * sizeof( T ));
            }

        void append( const T& element )
            {
                resize( _size + 1 );
                _data[ _size - 1 ] = element;
            }

        void replace( const void* newData, const uint64_t newSize )
            {
                EQASSERT( newData );
                EQASSERT( newSize );

                reserve( newSize );
                memcpy( _data, newData, newSize * sizeof( T ));
                _size = newSize;
            }

        void swap( Buffer& buffer )
            {
                T*             tmpData    = buffer._data;
                const uint64_t tmpSize    = buffer._size;
                const uint64_t tmpMaxSize = buffer._maxSize;

                buffer._data = _data;
                buffer._size = _size;
                buffer._maxSize = _maxSize;

                _data     = tmpData;
                _size     = tmpSize;
                _maxSize = tmpMaxSize;
            }

        T* getData() { return _data; }

        const T* getData() const { return _data; }

        bool setSize( const uint64_t size )
            {
                EQASSERT( size <= _maxSize );
                if( size > _maxSize )
                    return false;

                _size = size;
                return true;
            }
                    
        uint64_t getSize() const { return _size; }
        
        bool isEmpty() const { return (_size==0); }
        
        uint64_t getMaxSize() const { return _maxSize; }

    private:
        T*    _data;

        uint64_t _size;

        uint64_t _maxSize;
    };

    typedef Buffer< uint8_t > Bufferb;
}

}
#endif //EQBASE_BUFFER_H