MemoryStream.h

#pragma once
 
#include <Foundation/Basics.h>
#include <Foundation/Containers/HybridArray.h>
#include <Foundation/IO/Stream.h>
#include <Foundation/Strings/String.h>
#include <Foundation/Types/RefCounted.h>
 
class plMemoryStreamReader;
class plMemoryStreamWriter;
 
 
class PL_FOUNDATION_DLL plMemoryStreamStorageInterface
{
public:
  plMemoryStreamStorageInterface();
  virtual ~plMemoryStreamStorageInterface();
 
  plUInt32 GetStorageSize32() const
  {
    PL_ASSERT_ALWAYS(GetStorageSize64() <= plMath::MaxValue<plUInt32>(), "The memory stream storage object has grown beyond 4GB. The code using it has to be adapted to support this.");
    return (plUInt32)GetStorageSize64();
  }
 
  virtual plUInt64 GetStorageSize64() const = 0; // [tested]
 
  virtual void Clear() = 0;
 
  virtual void Compact() = 0;
 
  virtual plUInt64 GetHeapMemoryUsage() const = 0;
 
  void ReadAll(plStreamReader& inout_stream, plUInt64 uiMaxBytes = plMath::MaxValue<plUInt64>());
 
  virtual void Reserve(plUInt64 uiBytes) = 0;
 
  virtual plResult CopyToStream(plStreamWriter& inout_stream) const = 0;
 
  virtual plArrayPtr<const plUInt8> GetContiguousMemoryRange(plUInt64 uiStartByte) const = 0;
 
  virtual plArrayPtr<plUInt8> GetContiguousMemoryRange(plUInt64 uiStartByte) = 0;
 
private:
  virtual void SetInternalSize(plUInt64 uiSize) = 0;
 
  friend class plMemoryStreamReader;
  friend class plMemoryStreamWriter;
};
 
 
 
template <typename CONTAINER>
class plMemoryStreamContainerStorage : public plMemoryStreamStorageInterface
{
public:
  plMemoryStreamContainerStorage(plUInt32 uiInitialCapacity = 0, plAllocator* pAllocator = plFoundation::GetDefaultAllocator())
    : m_Storage(pAllocator)
  {
    m_Storage.Reserve(uiInitialCapacity);
  }
 
  virtual plUInt64 GetStorageSize64() const override { return m_Storage.GetCount(); }
  virtual void Clear() override { m_Storage.Clear(); }
  virtual void Compact() override { m_Storage.Compact(); }
  virtual plUInt64 GetHeapMemoryUsage() const override { return m_Storage.GetHeapMemoryUsage(); }
 
  virtual void Reserve(plUInt64 uiBytes) override
  {
    PL_ASSERT_DEV(uiBytes <= plMath::MaxValue<plUInt32>(), "plMemoryStreamContainerStorage only supports 32 bit addressable sizes.");
    m_Storage.Reserve(static_cast<plUInt32>(uiBytes));
  }
 
  virtual plResult CopyToStream(plStreamWriter& inout_stream) const override
  {
    return inout_stream.WriteBytes(m_Storage.GetData(), m_Storage.GetCount());
  }
 
  virtual plArrayPtr<const plUInt8> GetContiguousMemoryRange(plUInt64 uiStartByte) const override
  {
    if (uiStartByte >= m_Storage.GetCount())
      return {};
 
    return plArrayPtr<const plUInt8>(m_Storage.GetData() + uiStartByte, m_Storage.GetCount() - static_cast<plUInt32>(uiStartByte));
  }
 
  virtual plArrayPtr<plUInt8> GetContiguousMemoryRange(plUInt64 uiStartByte) override
  {
    if (uiStartByte >= m_Storage.GetCount())
      return {};
 
    return plArrayPtr<plUInt8>(m_Storage.GetData() + uiStartByte, m_Storage.GetCount() - static_cast<plUInt32>(uiStartByte));
  }
 
  const plUInt8* GetData() const { return m_Storage.GetData(); }
 
private:
  virtual void SetInternalSize(plUInt64 uiSize) override
  {
    PL_ASSERT_DEV(uiSize <= plMath::MaxValue<plUInt32>(), "Storage that large is not supported.");
    m_Storage.SetCountUninitialized(static_cast<plUInt32>(uiSize));
  }
 
  CONTAINER m_Storage;
};
 
 
 
 
class PL_FOUNDATION_DLL plContiguousMemoryStreamStorage : public plMemoryStreamContainerStorage<plHybridArray<plUInt8, 256>>
{
public:
  plContiguousMemoryStreamStorage(plUInt32 uiInitialCapacity = 0, plAllocator* pAllocator = plFoundation::GetDefaultAllocator())
    : plMemoryStreamContainerStorage<plHybridArray<plUInt8, 256>>(uiInitialCapacity, pAllocator)
  {
  }
};
 
class PL_FOUNDATION_DLL plDefaultMemoryStreamStorage final : public plMemoryStreamStorageInterface
{
public:
  plDefaultMemoryStreamStorage(plUInt32 uiInitialCapacity = 0, plAllocator* pAllocator = plFoundation::GetDefaultAllocator());
  ~plDefaultMemoryStreamStorage();
 
  virtual void Reserve(plUInt64 uiBytes) override;    // [tested]
 
  virtual plUInt64 GetStorageSize64() const override; // [tested]
  virtual void Clear() override;
  virtual void Compact() override;
  virtual plUInt64 GetHeapMemoryUsage() const override;
  virtual plResult CopyToStream(plStreamWriter& inout_stream) const override;
  virtual plArrayPtr<const plUInt8> GetContiguousMemoryRange(plUInt64 uiStartByte) const override; // [tested]
  virtual plArrayPtr<plUInt8> GetContiguousMemoryRange(plUInt64 uiStartByte) override;             // [tested]
 
private:
  virtual void SetInternalSize(plUInt64 uiSize) override;
 
  void AddChunk(plUInt32 uiMinimumSize);
 
  struct Chunk
  {
    plUInt64 m_uiStartOffset = 0;
    plArrayPtr<plUInt8> m_Bytes;
  };
 
  plHybridArray<Chunk, 16> m_Chunks;
 
  plUInt64 m_uiCapacity = 0;
  plUInt64 m_uiInternalSize = 0;
  plUInt8 m_InplaceMemory[512]; // used for the very first bytes, might cover small memory streams without an allocation
  mutable plUInt32 m_uiLastChunkAccessed = 0;
  mutable plUInt64 m_uiLastByteAccessed = 0;
};
 
 
template <typename CONTAINER>
class plMemoryStreamContainerWrapperStorage : public plMemoryStreamStorageInterface
{
public:
  plMemoryStreamContainerWrapperStorage(CONTAINER* pContainer) { m_pStorage = pContainer; }
 
  virtual plUInt64 GetStorageSize64() const override { return m_pStorage->GetCount(); }
  virtual void Clear() override { m_pStorage->Clear(); }
  virtual void Compact() override { m_pStorage->Compact(); }
  virtual plUInt64 GetHeapMemoryUsage() const override { return m_pStorage->GetHeapMemoryUsage(); }
 
  virtual void Reserve(plUInt64 uiBytes) override
  {
    PL_ASSERT_DEV(uiBytes <= plMath::MaxValue<plUInt32>(), "plMemoryStreamContainerWrapperStorage only supports 32 bit addressable sizes.");
    m_pStorage->Reserve(static_cast<plUInt32>(uiBytes));
  }
 
  virtual plResult CopyToStream(plStreamWriter& inout_stream) const override
  {
    return inout_stream.WriteBytes(m_pStorage->GetData(), m_pStorage->GetCount());
  }
 
  virtual plArrayPtr<const plUInt8> GetContiguousMemoryRange(plUInt64 uiStartByte) const override
  {
    if (uiStartByte >= m_pStorage->GetCount())
      return {};
 
    return plArrayPtr<const plUInt8>(m_pStorage->GetData() + uiStartByte, m_pStorage->GetCount() - static_cast<plUInt32>(uiStartByte));
  }
 
  virtual plArrayPtr<plUInt8> GetContiguousMemoryRange(plUInt64 uiStartByte) override
  {
    if (uiStartByte >= m_pStorage->GetCount())
      return {};
 
    return plArrayPtr<plUInt8>(m_pStorage->GetData() + uiStartByte, m_pStorage->GetCount() - static_cast<plUInt32>(uiStartByte));
  }
 
private:
  virtual void SetInternalSize(plUInt64 uiSize) override
  {
    PL_ASSERT_DEV(uiSize <= plMath::MaxValue<plUInt32>(), "plMemoryStreamContainerWrapperStorage only supports up to 4GB sizes.");
    m_pStorage->SetCountUninitialized(static_cast<plUInt32>(uiSize));
  }
 
  CONTAINER* m_pStorage;
};
 
 
 
class PL_FOUNDATION_DLL plMemoryStreamReader : public plStreamReader
{
public:
  plMemoryStreamReader(const plMemoryStreamStorageInterface* pStreamStorage = nullptr);
 
  ~plMemoryStreamReader();
 
  void SetStorage(const plMemoryStreamStorageInterface* pStreamStorage)
  {
    m_pStreamStorage = pStreamStorage;
    m_uiReadPosition = 0;
  }
 
  virtual plUInt64 ReadBytes(void* pReadBuffer, plUInt64 uiBytesToRead) override; // [tested]
 
  virtual plUInt64 SkipBytes(plUInt64 uiBytesToSkip) override; // [tested]
 
  void SetReadPosition(plUInt64 uiReadPosition); // [tested]
 
  plUInt64 GetReadPosition() const { return m_uiReadPosition; }
 
  plUInt32 GetByteCount32() const; // [tested]
  plUInt64 GetByteCount64() const; // [tested]
 
  void SetDebugSourceInformation(plStringView sDebugSourceInformation);
 
private:
  const plMemoryStreamStorageInterface* m_pStreamStorage = nullptr;
 
  plString m_sDebugSourceInformation;
 
  plUInt64 m_uiReadPosition = 0;
};
 
 
 
class PL_FOUNDATION_DLL plMemoryStreamWriter : public plStreamWriter
{
public:
  plMemoryStreamWriter(plMemoryStreamStorageInterface* pStreamStorage = nullptr);
 
  ~plMemoryStreamWriter();
 
  void SetStorage(plMemoryStreamStorageInterface* pStreamStorage)
  {
    m_pStreamStorage = pStreamStorage;
    m_uiWritePosition = 0;
    if (m_pStreamStorage)
      m_uiWritePosition = m_pStreamStorage->GetStorageSize64();
  }
 
  virtual plResult WriteBytes(const void* pWriteBuffer, plUInt64 uiBytesToWrite) override; // [tested]
 
  void SetWritePosition(plUInt64 uiWritePosition); // [tested]
 
  plUInt64 GetWritePosition() const { return m_uiWritePosition; }
 
  plUInt32 GetByteCount32() const; // [tested]
  plUInt64 GetByteCount64() const; // [tested]
 
private:
  plMemoryStreamStorageInterface* m_pStreamStorage = nullptr;
 
  plUInt64 m_uiWritePosition = 0;
};
 
 
 
class PL_FOUNDATION_DLL plRawMemoryStreamReader : public plStreamReader
{
public:
  plRawMemoryStreamReader();
 
  plRawMemoryStreamReader(const void* pData, plUInt64 uiDataSize); // [tested]
 
  template <typename CONTAINER>
  plRawMemoryStreamReader(const CONTAINER& container) // [tested]
  {
    Reset(container);
  }
 
  ~plRawMemoryStreamReader();
 
  void Reset(const void* pData, plUInt64 uiDataSize); // [tested]
 
  template <typename CONTAINER>
  void Reset(const CONTAINER& container)              // [tested]
  {
    Reset(static_cast<const plUInt8*>(container.GetData()), container.GetCount());
  }
 
  virtual plUInt64 ReadBytes(void* pReadBuffer, plUInt64 uiBytesToRead) override; // [tested]
 
  virtual plUInt64 SkipBytes(plUInt64 uiBytesToSkip) override; // [tested]
 
  void SetReadPosition(plUInt64 uiReadPosition); // [tested]
 
  plUInt64 GetReadPosition() const { return m_uiReadPosition; }
 
  plUInt64 GetByteCount() const; // [tested]
 
  void SetDebugSourceInformation(plStringView sDebugSourceInformation);
 
private:
  const plUInt8* m_pRawMemory = nullptr;
 
  plUInt64 m_uiChunkSize = 0;
  plUInt64 m_uiReadPosition = 0;
 
  plString m_sDebugSourceInformation;
};
 
 
 
class PL_FOUNDATION_DLL plRawMemoryStreamWriter : public plStreamWriter
{
public:
  plRawMemoryStreamWriter(); // [tested]
 
  plRawMemoryStreamWriter(void* pData, plUInt64 uiDataSize); // [tested]
 
  template <typename CONTAINER>
  plRawMemoryStreamWriter(CONTAINER& ref_container) // [tested]
  {
    Reset(ref_container);
  }
 
  ~plRawMemoryStreamWriter();                   // [tested]
 
  void Reset(void* pData, plUInt64 uiDataSize); // [tested]
 
  template <typename CONTAINER>
  void Reset(CONTAINER& ref_container)          // [tested]
  {
    Reset(static_cast<plUInt8*>(ref_container.GetData()), ref_container.GetCount());
  }
 
  plUInt64 GetStorageSize() const; // [tested]
 
  plUInt64 GetNumWrittenBytes() const; // [tested]
 
  void SetDebugSourceInformation(plStringView sDebugSourceInformation);
 
  virtual plResult WriteBytes(const void* pWriteBuffer, plUInt64 uiBytesToWrite) override; // [tested]
 
private:
  plUInt8* m_pRawMemory = nullptr;
 
  plUInt64 m_uiChunkSize = 0;
  plUInt64 m_uiWritePosition = 0;
 
  plString m_sDebugSourceInformation;
};