buffer.h

Go to the documentation of this file.

 
#pragma once
 
#include <cassert>
#include <promeki/core/namespace.h>
#include <promeki/core/list.h>
#include <promeki/core/sharedptr.h>
#include <promeki/core/memspace.h>
#include <promeki/core/error.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class Buffer {
        PROMEKI_SHARED_FINAL(Buffer)
        public:
                using Ptr = SharedPtr<Buffer>;
 
                static size_t getPageSize();
 
                static const size_t DefaultAlign;
 
                using List = promeki::List<Buffer>;
 
                using PtrList = promeki::List<Ptr>;
 
                Buffer() = default;
 
                Buffer(size_t sz, size_t an = DefaultAlign, const MemSpace &ms = MemSpace::Default) :
                        _alloc(ms.alloc(sz, an))
                {
                        _data = _alloc.ptr;
                }
 
                Buffer(void *p, size_t sz, size_t an = 0, bool own = false, const MemSpace &ms = MemSpace::Default) :
                        _data(p), _owned(own)
                {
                        _alloc.ptr = p;
                        _alloc.size = sz;
                        _alloc.align = an;
                        _alloc.ms = ms;
                }
 
                Buffer(const Buffer &o) : _owned(true), _size(o._size) {
                        if(o._data != nullptr) {
                                _alloc = o._alloc.ms.alloc(o._alloc.size, o._alloc.align);
                                if(_alloc.ptr == nullptr) { _size = 0; return; }
                                o._alloc.ms.copy(o._alloc, _alloc, _alloc.size);
                                size_t shift = static_cast<uint8_t *>(o._data) - static_cast<uint8_t *>(o._alloc.ptr);
                                _data = static_cast<uint8_t *>(_alloc.ptr) + shift;
                        }
                }
 
                Buffer &operator=(const Buffer &o) {
                        if(this == &o) return *this;
                        if(_owned) _alloc.ms.release(_alloc);
                        _data = nullptr;
                        _owned = true;
                        _size = 0;
                        _alloc = {};
                        if(o._data != nullptr) {
                                _alloc = o._alloc.ms.alloc(o._alloc.size, o._alloc.align);
                                if(_alloc.ptr != nullptr) {
                                        o._alloc.ms.copy(o._alloc, _alloc, _alloc.size);
                                        size_t shift = static_cast<uint8_t *>(o._data) - static_cast<uint8_t *>(o._alloc.ptr);
                                        _data = static_cast<uint8_t *>(_alloc.ptr) + shift;
                                        _size = o._size;
                                }
                        }
                        return *this;
                }
 
                Buffer(Buffer &&o) noexcept :
                        _alloc(o._alloc), _data(o._data), _owned(o._owned), _size(o._size)
                {
                        o._alloc = {};
                        o._data = nullptr;
                        o._owned = false;
                        o._size = 0;
                }
 
                Buffer &operator=(Buffer &&o) noexcept {
                        if(this == &o) return *this;
                        if(_owned) _alloc.ms.release(_alloc);
                        _alloc = o._alloc;
                        _data = o._data;
                        _owned = o._owned;
                        _size = o._size;
                        o._alloc = {};
                        o._data = nullptr;
                        o._owned = false;
                        o._size = 0;
                        return *this;
                }
 
                ~Buffer() {
                        if(_owned) _alloc.ms.release(_alloc);
                }
 
                bool isValid() const { return _data != nullptr; }
 
                void *data() const { return _data; }
 
                void *odata() const { return _alloc.ptr; }
 
                size_t size() const { return _size; }
 
                void setSize(size_t s) const {
                        assert(s <= availSize());
                        _size = s;
                        return;
                }
 
                size_t availSize() const {
                        if(_data == nullptr) return 0;
                        return _alloc.size - static_cast<size_t>(
                                static_cast<uint8_t *>(_data) -
                                static_cast<uint8_t *>(_alloc.ptr)
                        );
                }
 
                size_t allocSize() const { return _alloc.size; }
 
                size_t align() const { return _alloc.align; }
 
                const MemSpace &memSpace() const { return _alloc.ms; }
 
                const MemAllocation &allocation() const { return _alloc; }
 
                void shiftData(size_t bytes) {
                        assert(bytes <= _alloc.size);
                        _data = static_cast<uint8_t *>(_alloc.ptr) + bytes;
                        _size = 0;
                        return;
                }
 
                bool isHostAccessible() const { return _alloc.ms.isHostAccessible(_alloc); }
 
                void setOwnershipEnabled(bool val) {
                        _owned = val;
                        return;
                }
 
                Error fill(char value) const {
                        return _alloc.ms.fill(_data, availSize(), value);
                }
 
                Error copyFrom(const void *src, size_t bytes, size_t offset = 0) const;
 
        private:
                MemAllocation   _alloc;
                void            *_data          = nullptr;
                bool            _owned          = true;
                mutable size_t  _size           = 0;
};
 
PROMEKI_NAMESPACE_END