Buffer.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_BUFFER_H_
#define _MIRA_BUFFER_H_

#include <memory>
#include <stdexcept>
#include <vector>

#include <platform/Types.h>

#ifndef Q_MOC_RUN
#include <boost/type_traits.hpp>
#endif

#include <serialization/ReflectorInterface.h>
#include <serialization/Array.h>
#include <serialization/IsTransparentSerializable.h>
#include <serialization/ReflectorMacros.h>

namespace mira {


template <typename T, typename Alloc = std::allocator<T> >
class Buffer
{
    // the is_pod check is too hard here, since user defined constructors
    // are allowed, as long there is a trivial default constructor,
    // copy constructor and trivial destructor
    static_assert(boost::has_trivial_destructor<T>::value,
            "Can be used with types that have trivial destructor only");
#ifndef MIRA_WINDOWS
    // VC++2010 does not yet support the "Explicitly-defaulted and deleted
    // special member functions"-syntax, therefore we must skip these checks
    static_assert(boost::has_trivial_default_constructor<T>::value,
            "Can be used with types that have a trivial default constructor only");
    static_assert(boost::has_trivial_copy_constructor<T>::value,
            "Can be used with types that have a trivial copy constructor only");
#endif

    // TODO: The standard library has renamed all of the above has_trivial_XYZ to
    //       is_trivially_XYZable WITHOUT providing the old versions for
    //       backward compatibility. Therefore, the following code works on
    //       GCC >= 4.8 but fails on previous GCCs versions and MSVC. Therefore,
    //       we prefer to use the boost variants above, which seem to be more
    //       stable than the standard
    //static_assert(std::is_trivially_destructible<T>::value,
    //      "Can be used with types that have trivial destructor only");
    //static_assert(std:::is_trivially_default_constructible<T>::value,
    //      "Can be used with types that have a trivial default constructor only");
    //static_assert(std::is_trivially_copy_constructible<T>::value,
    //      "Can be used with types that have a trivial copy constructor only");


public:

    // some STL conform typedefs
    typedef T                               value_type;
    typedef typename Alloc::pointer         pointer;
    typedef typename Alloc::const_pointer   const_pointer;
    typedef typename Alloc::reference       reference;
    typedef typename Alloc::const_reference const_reference;
    typedef T*                              iterator;
    typedef const T*                        const_iterator;
    typedef std::size_t                     size_type;
    typedef ptrdiff_t                       difference_type;
    typedef Alloc                           allocator_type;

private:

    void init() {
        mBuffer = NULL;
        mReserved = mSize = 0;
        mBufferCreated = false;
        mTakenVector = NULL;
    }

public:

    Buffer() {
        init();
    }

    /*
     * Create a buffer and allocate memory of size size
     */
    Buffer(size_type size) {
        init();
        resize(size);
    }

    Buffer(T* carray, size_type size) {
        mBuffer = carray;
        mReserved = mSize = size;
        mBufferCreated = false;
        mTakenVector = NULL;
    }

    Buffer(std::vector<T>&& other)
    {
        mTakenVector = new std::vector<T>;
        mTakenVector->swap(other);

        mBuffer = &(*mTakenVector)[0];
        mReserved = mTakenVector->capacity();
        mSize = mTakenVector->size();
        mBufferCreated = false;
    }

    ~Buffer() {
        setBuffer(NULL, 0);
    }

public:

    Buffer(const Buffer& other) {
        init();
        copy(other);
    }

    Buffer& operator=(const Buffer& other) {
        copy(other);
        return *this;
    }

    void copy(const Buffer& other) {
        resize(other.size());
        memcpy(mBuffer, other.data(), other.size()*sizeof(T));
    }

public:
    // Move semantic

    Buffer(Buffer&& other) noexcept {
        init();
        swap(other);
    }

    Buffer& operator=(Buffer&& other) noexcept {
        swap(other);
        return *this;
    }

    void swap(Buffer& other) {
        std::swap(mBuffer, other.mBuffer);
        std::swap(mSize, other.mSize);
        std::swap(mReserved, other.mReserved);
        std::swap(mBufferCreated, other.mBufferCreated);
        std::swap(mTakenVector, other.mTakenVector);
    }

public:

    bool operator==(const Buffer& other) const {
        if(size()!=other.size())
            return false;
        assert(sizeInBytes()==other.sizeInBytes());
        return memcmp(data(), other.data(), sizeInBytes()) == 0;
    }

    bool operator!=(const Buffer& other) const {
        return !operator==(other);
    }

public:

    iterator begin() { return mBuffer; }

    const_iterator begin() const { return mBuffer; }

    iterator end() { return mBuffer+mSize; } // also works if empty

    const_iterator end() const { return mBuffer+mSize; }

public:
    size_type max_size () const { return mAllocator.max_size(); }

    size_type size() const { return mSize; }

    size_type sizeInBytes() const { return mSize * sizeof(T); }

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

    size_type capacity () const { return mReserved; }

    allocator_type get_allocator() const { return mAllocator; }

public:

    void reserve(size_type reserve)
    {
        if(reserve > mReserved)
        {
            std::size_t newSize = mReserved;
            if(newSize==0)
                newSize=1;
            while(reserve > newSize)
                newSize *= 2;

            T* newBuffer = mAllocator.allocate(newSize);
            if(mBuffer!=NULL)
                memcpy(newBuffer, mBuffer, mSize*sizeof(T));
            setBuffer(newBuffer, newSize);
            mBufferCreated = true;
        }
    }

public:

    void resize(size_type size)
    {
        reserve(size); // make sure buffer is big enough
        mSize = size;
    }

public:

    void push_back(const T& x) {
        resize(mSize+1);
        mBuffer[mSize-1] = x;
    }

    void push_back(T* data, size_type size) {
        push_back(Buffer<T>(data, size));
    }

    void push_back(const Buffer<T>& data) {
        size_type oldSize = mSize;
        resize(mSize + data.size());
        memcpy(mBuffer+oldSize*sizeof(T), data.data(), data.sizeInBytes());
    }

    void pop_back() {
        pop_back(1);
    }

    void pop_back(size_type elements) {
        if (elements >= mSize)
        {
            this->clear();
            return;
        }
        resize(mSize-elements);
    }

    void pop_front() {
        pop_front(1);
    }

    void pop_front(size_type elements) {
        if (elements >= mSize)
        {
            clear();
            return;
        }
        // Move the memory
        if (elements > 0)
        {
            memmove(mBuffer, mBuffer+elements*sizeof(T), (mSize-elements)*sizeof(T));
            resize(mSize-elements);
        }
    }

    void clear() {
        mSize = 0;
    }

public:

    reference operator[] ( size_type n ) {
        assert(n<mSize);
        return mBuffer[n];
    }

    const_reference operator[] ( size_type n ) const {
        assert(n<mSize);
        return mBuffer[n];
    }

    reference at(size_type n) {
        rangeCheck(n);
        return mBuffer[n];
    }

    const_reference at(size_type n) const {
        rangeCheck(n);
        return mBuffer[n];
    }

    reference front() {
        assert(mSize>0);
        return mBuffer[0];
    }

    const_reference front() const {
        assert(mSize>0);
        return mBuffer[0];
    }

    reference back() {
        assert(mSize>0);
        return mBuffer[size()-1];
    }

    const_reference back() const {
        assert(mSize>0);
        return mBuffer[size()-1];
    }

    pointer data() { return mBuffer; }

    const_pointer data() const { return mBuffer; }

protected:

    void rangeCheck(size_type n) const
    {
        if (n >= size())
            throw std::out_of_range("Buffer::range_check");
    }

private:

    void setBuffer(T* newBuffer, size_type size)
    {
        // delete old buffer, if any
        if(mBufferCreated)
            mAllocator.deallocate(mBuffer,mReserved);

        // data might have come from a taken over vector, which now is no longer needed
        delete mTakenVector;
        mTakenVector = NULL;

        mBuffer = newBuffer;
        mReserved = size;
    }

protected:

    T* mBuffer;         
    size_type mSize;    
    size_type mReserved;
    bool mBufferCreated;

    Alloc mAllocator;   

    std::vector<T>* mTakenVector; 
};


template<typename Reflector, typename T, typename Allocator>
void reflectRead(Reflector& r, Buffer<T, Allocator>& c)
{
    // store the size first
    uint32 count = c.size();
    {
        typedef Buffer<T, Allocator> Buffer;
        MIRA_REFLECT_CALL(Reflector, r, "Buffer ReflectCollectionCount",
                          (serialization::ReflectCollectionCount<Reflector,Buffer>::reflect(r, count)));
    }
    // store the elements as array
    serialization::PlainArray<T> array(c.data(), c.size());
    r.delegate(array);
}

template<typename Reflector, typename T, typename Allocator>
void reflectWrite(Reflector& r, Buffer<T, Allocator>& c)
{
    // restore the size first
    uint32 count;
    {
        typedef Buffer<T, Allocator> Buffer;
        MIRA_REFLECT_CALL(Reflector, r, "Buffer ReflectCollectionCount",
                          (serialization::ReflectCollectionCount<Reflector,Buffer>::reflect(r, count)));
    }
    // reserve the space and create the elements
    c.resize(count);
    // restore the elements as array
    serialization::PlainArray<T> array(c.data(), c.size());
    r.delegate(array);
}

template<typename Reflector, typename T, typename Allocator>
void reflect(Reflector& r, Buffer<T, Allocator>& c)
{
    splitReflect(r, c);
}

template<typename T, typename Allocator>
class IsObjectTrackable<Buffer<T, Allocator>> : public std::false_type {};

template<typename T, typename Allocator>
class IsCollection<Buffer<T, Allocator>> : public std::true_type {};


}

#endif