Buffer.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Math/Alge/Alge.h"

namespace honey
{


template<class T>
class Buffer
{
public:
    typedef T   value_type;
    typedef szt size_type;
    typedef sdt difference_type;
    typedef T&  reference;
    typedef T*  pointer;
    typedef T*  iterator;
    typedef std::reverse_iterator<iterator>         reverse_iterator;
    
    Buffer()                                        { reset(); }
    Buffer(T* data, szt size)                       { reset(data, size); }
    template<class U>
    Buffer(vector<U>& list)                         { reset(list.data(), list.size()); }
    template<class U>
    Buffer(const vector<U>& list)                   { reset(list.data(), list.size()); }
    template<class U, szt N>
    Buffer(array<U,N>& list)                        { reset(list.data(), list.size()); }
    template<class U, szt N>
    Buffer(const array<U,N>& list)                  { reset(list.data(), list.size()); }
    Buffer(const Buffer& rhs)                       { operator=(rhs); }
    Buffer(Buffer&& rhs)                            { operator=(move(rhs)); }
    
    Buffer& operator=(const Buffer& rhs)            { reset(rhs._data, rhs._size); return *this; }
    Buffer& operator=(Buffer&& rhs)                 { reset(rhs._data, rhs._size); rhs.reset(); return *this; }
    
    T& at(szt pos) const                            { if (pos >= _size) throw std::out_of_range("invalid buffer index"); return _data[pos]; }
    T& operator[](szt pos) const                    { return _data[pos]; }
    T& front() const                                { return _data[0]; }
    T& back() const                                 { return _data[_size - 1]; }
    T* data() const                                 { return _data; }

    Buffer slice(szt pos, optional<szt> size = optnull) const   { szt begin = Alge::clamp(pos, 0, _size), end = size ? Alge::clamp(pos + *size, 0, _size) : _size; return Buffer(_data + begin, end - begin); }

    T* begin() const                                { return _data; }
    T* end() const                                  { return _data + _size; }
    reverse_iterator rbegin() const                 { return reverse_iterator(_data + _size); }
    reverse_iterator rend() const                   { return reverse_iterator(_data); }
    
    bool empty() const                              { return !_data || !_size; }
    explicit operator bool() const                  { return !empty(); }
    szt size() const                                { return _size; }
    
    bool operator==(const Buffer& rhs) const        { return _data == rhs._data && _size == rhs._size; }
    bool operator!=(const Buffer& rhs) const        { return !operator==(rhs); }
    
    void reset()                                    { _data = nullptr; _size = 0; }
    void reset(T* data, szt size)                   { _data = data; _size = size; }
    
    operator Buffer<const T>() const                { return Buffer<const T>(_data, _size); }
    
private:
    T* _data;
    szt _size;
};

}