Stream.h

 
#pragma once
 
#include <Foundation/Basics.h>
#include <Foundation/Containers/ArrayBase.h>
#include <Foundation/Containers/HashTable.h>
#include <Foundation/Containers/Map.h>
#include <Foundation/Containers/Set.h>
#include <Foundation/Containers/SmallArray.h>
#include <Foundation/Math/Math.h>
#include <Foundation/Memory/EndianHelper.h>
 
using plTypeVersion = plUInt16;
 
template <plUInt16 Size, typename AllocatorWrapper>
struct plHybridString;
 
using plString = plHybridString<32, plDefaultAllocatorWrapper>;
 
class PL_FOUNDATION_DLL plStreamReader
{
  PL_DISALLOW_COPY_AND_ASSIGN(plStreamReader);
 
public:
  plStreamReader();
 
  virtual ~plStreamReader();
 
  virtual plUInt64 ReadBytes(void* pReadBuffer, plUInt64 uiBytesToRead) = 0; // [tested]
 
  template <typename T>
  plResult ReadWordValue(T* pWordValue); // [tested]
 
  template <typename T>
  plResult ReadDWordValue(T* pDWordValue); // [tested]
 
  template <typename T>
  plResult ReadQWordValue(T* pQWordValue); // [tested]
 
  template <typename ArrayType, typename ValueType>
  plResult ReadArray(plArrayBase<ValueType, ArrayType>& inout_array); // [tested]
 
  template <typename ValueType, plUInt16 uiSize, typename AllocatorWrapper>
  plResult ReadArray(plSmallArray<ValueType, uiSize, AllocatorWrapper>& ref_array);
 
  template <typename ValueType, plUInt32 uiSize>
  plResult ReadArray(ValueType (&array)[uiSize]);
 
  template <typename KeyType, typename Comparer>
  plResult ReadSet(plSetBase<KeyType, Comparer>& inout_set); // [tested]
 
  template <typename KeyType, typename ValueType, typename Comparer>
  plResult ReadMap(plMapBase<KeyType, ValueType, Comparer>& inout_map); // [tested]
 
  template <typename KeyType, typename ValueType, typename Hasher>
  plResult ReadHashTable(plHashTableBase<KeyType, ValueType, Hasher>& inout_hashTable); // [tested]
 
  plResult ReadString(plStringBuilder& ref_sBuilder); // [tested]
 
  plResult ReadString(plString& ref_sString);
 
 
  virtual plUInt64 SkipBytes(plUInt64 uiBytesToSkip)
  {
    plUInt8 uiTempBuffer[1024];
 
    plUInt64 uiBytesSkipped = 0;
 
    while (uiBytesSkipped < uiBytesToSkip)
    {
      plUInt64 uiBytesToRead = plMath::Min<plUInt64>(uiBytesToSkip - uiBytesSkipped, 1024);
 
      plUInt64 uiBytesRead = ReadBytes(uiTempBuffer, uiBytesToRead);
 
      uiBytesSkipped += uiBytesRead;
 
      // Terminate early if the stream didn't read as many bytes as we requested (EOF for example)
      if (uiBytesRead < uiBytesToRead)
        break;
    }
 
    return uiBytesSkipped;
  }
 
  PL_ALWAYS_INLINE plTypeVersion ReadVersion(plTypeVersion expectedMaxVersion);
};
 
class PL_FOUNDATION_DLL plStreamWriter
{
  PL_DISALLOW_COPY_AND_ASSIGN(plStreamWriter);
 
public:
  plStreamWriter();
 
  virtual ~plStreamWriter();
 
  virtual plResult WriteBytes(const void* pWriteBuffer, plUInt64 uiBytesToWrite) = 0; // [tested]
 
  virtual plResult Flush() // [tested]
  {
    return PL_SUCCESS;
  }
 
  template <typename T>
  plResult WriteWordValue(const T* pWordValue); // [tested]
 
  template <typename T>
  plResult WriteDWordValue(const T* pDWordValue); // [tested]
 
  template <typename T>
  plResult WriteQWordValue(const T* pQWordValue); // [tested]
 
  PL_ALWAYS_INLINE void WriteVersion(plTypeVersion version);
 
  template <typename ArrayType, typename ValueType>
  plResult WriteArray(const plArrayBase<ValueType, ArrayType>& array); // [tested]
 
  template <typename ValueType, plUInt16 uiSize>
  plResult WriteArray(const plSmallArrayBase<ValueType, uiSize>& array);
 
  template <typename ValueType, plUInt32 uiSize>
  plResult WriteArray(const ValueType (&array)[uiSize]);
 
  template <typename KeyType, typename Comparer>
  plResult WriteSet(const plSetBase<KeyType, Comparer>& set); // [tested]
 
  template <typename KeyType, typename ValueType, typename Comparer>
  plResult WriteMap(const plMapBase<KeyType, ValueType, Comparer>& map); // [tested]
 
  template <typename KeyType, typename ValueType, typename Hasher>
  plResult WriteHashTable(const plHashTableBase<KeyType, ValueType, Hasher>& hashTable); // [tested]
 
  plResult WriteString(const plStringView sStringView); // [tested]
};
 
// Contains the helper methods of both interfaces
#include <Foundation/IO/Implementation/Stream_inl.h>
 
// Standard operators for overloads of common data types
#include <Foundation/IO/Implementation/StreamOperations_inl.h>
 
#include <Foundation/IO/Implementation/StreamOperationsMath_inl.h>
 
#include <Foundation/IO/Implementation/StreamOperationsOther_inl.h>