buffer.h

/* Copyright (c) 2007-2016, Stefan Eilemann <eile@equalizergraphics.com>
 *                          Daniel Nachbaur <danielnachbaur@gmail.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 LUNCHBOX_BUFFER_H
#define LUNCHBOX_BUFFER_H

#include <lunchbox/debug.h>       // LBASSERT macro
#include <lunchbox/os.h>          // setZero used inline
#include <lunchbox/types.h>

#include <cstdlib>      // for malloc
#include <cstring>      // for memcpy

namespace lunchbox
{
template< class T > class Buffer
{
public:
    Buffer() : _data( nullptr ), _size( 0 ), _maxSize( 0 ) {}

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

    explicit Buffer( const Buffer& from );

    explicit Buffer( Buffer&& from );

    ~Buffer() { clear(); }

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

    T* pack();

    Buffer& operator = ( const Buffer& from );

    Buffer& operator = ( Buffer&& from );

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

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

    T* resize( const uint64_t newSize );

    void grow( const uint64_t newSize );

    T* reserve( const uint64_t newSize );

    T* reset( const uint64_t newSize );

    void setZero() { ::lunchbox::setZero( _data, _size ); }

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

    void append( const T& element );

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

    void replace( const Buffer& from ) { replace( from._data, from._size ); }

    void swap( Buffer& buffer );

    T* getData() { return _data; }

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

    bool setSize( const uint64_t size );

    uint64_t getSize() const { return _size; }

    uint64_t getNumBytes() const { return _size * sizeof( T ); }

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

    uint64_t getMaxSize() const { return _maxSize; }

private:
    T* _data;

    uint64_t _size;

    uint64_t _maxSize;
};
}

#include "buffer.ipp" // template implementation

#endif //LUNCHBOX_BUFFER_H