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);
    }

    Buffer(const Buffer& from);

    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