MemoryBuffer.h

#pragma once
 
#include "Allocator.h"
 
#include "../StringView.h"
 
#include <glm/ext/quaternion_float.hpp>
#include <glm/ext/matrix_float4x4.hpp>
#include <glm/ext/vector_float3.hpp>
#include <glm/ext/vector_float4.hpp>
 
#include <string>
#include <utility>
 
namespace Cogs
{
  namespace Memory
  {
    COGSFOUNDATION_API std::string MemToHexString(const void* memory, size_t size);
 
    class COGSFOUNDATION_API MemoryBuffer
    {
    public:
      enum class Anchor
      {
        Start,    // Seek position is relative to the start of the data.
        Current,  // Seek position is relative to the current read/write position.
        End       // Seek position is relative to the end of the data.
      };
 
      MemoryBuffer() = default;
 
      MemoryBuffer(MemBlockType type) : type(type) {}
 
      MemoryBuffer(size_t size, MemBlockType type) : type(type) { resize(size, false, false); }
 
      MemoryBuffer(size_t size, bool onlyReserve = false, MemBlockType type = MemBlockType::Block)
        : type(type)
      {
        if (onlyReserve) {
          reserve(size);
        }
        else {
          resize(size, false, false);
        }
      }
 
      MemoryBuffer(Allocator * allocator, MemBlockType type = MemBlockType::Block)
        : allocator(allocator), type(type)
      {}
 
      MemoryBuffer(size_t size, Allocator * allocator, MemBlockType type = MemBlockType::Block)
        : allocator(allocator), type(type)
      {
        resize(size, false, false);
      }
 
      MemoryBuffer(const void* memory, size_t size);
 
      MemoryBuffer(MemoryBuffer && other) noexcept
      {
        buffer = other.buffer;
        currentSize = other.currentSize;
        storageSize = other.storageSize;
        currentPos = other.currentPos;
        allocator = other.allocator;
        type = other.type;
 
        other.buffer = nullptr;
        other.currentSize = 0;
        other.storageSize = 0;
        other.currentPos = 0;
        other.type = MemBlockType::Block;
      }
 
      MemoryBuffer & operator=(MemoryBuffer && other) noexcept
      {
        release();
 
        buffer = other.buffer;
        currentSize = other.currentSize;
        storageSize = other.storageSize;
        currentPos = other.currentPos;
        allocator = other.allocator;
        type = other.type;
 
        other.buffer = nullptr;
        other.currentSize = 0;
        other.storageSize = 0;
        other.currentPos = 0;
        other.type = MemBlockType::Block;
        return *this;
      }
 
      MemoryBuffer(const MemoryBuffer &) = delete;
      MemoryBuffer & operator=(const MemoryBuffer &) = delete;
 
      ~MemoryBuffer()
      {
        release();
      }
 
      void changeType(MemBlockType newType);
 
      void reset(size_t size, Allocator * allocator);
 
      bool resize(size_t size, bool keep = true, bool forceRealloc = false);
      bool reserve(size_t size);
 
      void copy(const MemoryBuffer & other);
 
      void clear() { resize(0, false, true); }
 
      void * data() { return buffer; }
      const void * data() const { return buffer; }
 
      void * dataFromPos()                  { return static_cast<uint8_t*>(buffer) + currentPos; }
      const void * dataFromPos() const      { return static_cast<const uint8_t*>(buffer) + currentPos; }
 
      size_t size() const { return currentSize; }
      size_t capacity() const { return storageSize; }
      bool empty() const { return currentSize == 0; }
 
      void* grow(size_t bytes) {
        if (storageSize < (currentSize + bytes)) {
          if (!reserve(std::max<size_t>(128, ((storageSize + bytes) * 3) / 2))) {
            return nullptr;
          }
        }
        void* rv = static_cast<uint8_t*>(buffer) + currentSize;
        currentSize += bytes;
        return rv;
      }
 
      void swap(MemoryBuffer & other);
 
      const Allocator * getAllocator() const { return allocator; }
 
      size_t      read(void* buffer, size_t noofbytes);
      uint8_t     read8()                                     { return readImpl<uint8_t>(); }
      uint16_t    read16()                                    { return readImpl<uint16_t>(); }
      uint32_t    read32()                                    { return readImpl<uint32_t>(); }
      uint64_t    read64()                                    { return readImpl<uint64_t>(); }
      float       readFloat()                                 { return readImpl<float>(); }
      double      readDouble()                                { return readImpl<double>(); }
      glm::vec2   readFloat2();
      glm::vec3   readFloat3();
      glm::vec4   readFloat4();
      glm::quat   readQuaternion();
      glm::mat4   readMatrix();
      std::string readString();
 
      bool        write(const void* buffer, size_t noofbytes);
      bool        write8(uint8_t value)                       { return write(&value, sizeof(value)); }
      bool        write16(uint16_t value)                     { return write(&value, sizeof(value)); }
      bool        write32(uint32_t value)                     { return write(&value, sizeof(value)); }
      bool        write64(uint64_t value)                     { return write(&value, sizeof(value)); }
      bool        writeFloat(float value)                     { return write(&value, sizeof(value)); }
      bool        writeDouble(double value)                   { return write(&value, sizeof(value)); }
      bool        writeFloat2(const glm::vec2& value);
      bool        writeFloat3(const glm::vec3& value);
      bool        writeFloat4(const glm::vec4& value);
      bool        writeQuaternion(const glm::quat& value);
      bool        writeMatrix(const glm::mat4& value);
      bool        writeString(const StringView& str);
 
      void        seek(int64_t offset, Anchor from);
 
      size_t      pos() const                                 { return currentPos; }
      size_t      unreadSize() const                          { return size() - pos(); }
 
      bool        areContentsEqual(const MemoryBuffer& rhs) const;
 
    private:
      void *      buffer = nullptr;
      size_t      currentSize = 0;
      size_t      storageSize = 0;
      size_t      currentPos = 0;
      Allocator * allocator = Allocator::defaultAllocator();
      MemBlockType type = MemBlockType::Block;
 
      void        release();
 
      template<typename T> T readImpl() {
        T value = {};
 
        read(&value, sizeof(value));
        return value;
      }
    };
 
    template<typename T>
    class TypedBuffer
    {
    public:
      typedef T value_type;
 
      TypedBuffer() {}
      TypedBuffer(MemBlockType type) : buffer(type) {}
      TypedBuffer(Memory::Allocator * allocator, MemBlockType type = MemBlockType::Block) : buffer(allocator, type) {}
      TypedBuffer(size_t size, MemBlockType type = MemBlockType::Block) : buffer(sizeof(T) * size, type) {}
      TypedBuffer(size_t size, Memory::Allocator * allocator, MemBlockType type = MemBlockType::Block) : buffer(sizeof(T) * size, allocator, type) {}
 
      TypedBuffer(const TypedBuffer &) = delete;
      TypedBuffer & operator=(const TypedBuffer &) = delete;
 
      TypedBuffer(TypedBuffer && other) noexcept = default;
      TypedBuffer & operator=(TypedBuffer &&) noexcept = default;
 
      bool resize(size_t size, bool keep = true, bool forceRealloc = false) { return buffer.resize(sizeof(T) * size, keep, forceRealloc); }
 
      bool reserve(size_t size) { return buffer.reserve(sizeof(T) * size); }
 
      T & operator[](size_t i)
      {
#ifdef _DEBUG
        assert(buffer.data() != nullptr);
        assert(i < size());
#endif
        return static_cast<T*>(buffer.data())[i];
      }
 
      const T & operator[](size_t i) const
      {
#ifdef _DEBUG
        assert(buffer.data() != nullptr);
        assert(i < size());
#endif
        return static_cast<const T*>(buffer.data())[i];
      }
 
      void swap(TypedBuffer & other)
      {
        std::swap(buffer, other.buffer);
      }
 
      void copy(const TypedBuffer & other)
      {
        buffer.copy(other.buffer);
      }
 
      void clear() { buffer.clear(); }
 
      T * data() { return static_cast<T*>(buffer.data()); }
      const T * data() const { return static_cast<const T*>(buffer.data()); }
 
      T * begin() { return data(); }
      const T * begin() const { return data(); }
 
      T * end() { return begin() + size(); }
      const T * end() const { return begin() + size(); }
 
      size_t size() const { return buffer.size() / sizeof(T); }
 
      bool empty() const { return buffer.empty(); }
 
      size_t byteSize() const { return buffer.size(); }
 
      T& grow() { return *static_cast<T*>(buffer.grow(sizeof(T))); }
 
    protected:
      MemoryBuffer buffer;
    };
  }
}