buffer.h

/* Copyright (c) 2007-2011, 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 COBASE_BUFFER_H
#define COBASE_BUFFER_H

#include <co/base/debug.h>       // EQASSERT macro
#include <co/base/types.h>

#include <cstdlib>      // for malloc

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

        Buffer( const uint64_t size ) : _data(0), _size(0), _maxSize(0)
            { reset( size ); }

        ~Buffer() { clear(); }

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

        T* pack()
            {
                if( _maxSize != _size )
                {
                    _data = static_cast< T* >( realloc( _data,
                                                        _size * sizeof( T )));
                    _maxSize = _size;
                }
                return _data;
            }

        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 uint64_t position )
            { EQASSERT( _size > position ); return _data[ position ]; }

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

        T* resize( const uint64_t newSize )
            { 
                _size = newSize;
                if( newSize <= _maxSize )
                    return _data;

                // avoid excessive reallocs
                const uint64_t nElems = newSize + (newSize >> 3);
                const uint64_t nBytes = nElems * sizeof( T );
                _data = static_cast< T* >( realloc( _data, nBytes ));
                _maxSize = nElems;
                return _data;
            }

        void grow( const uint64_t newSize )
            { 
                if( newSize > _size )
                    resize( newSize );
            }

        T* reserve( const uint64_t newSize )
            {
                if( newSize <= _maxSize )
                    return _data;

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

        T* reset( const uint64_t newSize )
            {
                reserve( newSize );
                setSize( newSize );
                return _data;
            }

        void append( const T* data, const uint64_t size )
            {
                EQASSERT( data );
                EQASSERT( size );

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

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

        void replace( const void* data, const uint64_t size )
            {
                EQASSERT( data );
                EQASSERT( size );

                reserve( size );
                memcpy( _data, data, size * sizeof( T ));
                _size = size;
            }

        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 //COBASE_BUFFER_H