1 files changed, 103 insertions, 124 deletions

diff --git a/core/src/Utils/IO/DataStream.hpp b/core/src/Utils/IO/DataStream.hpp
index 8dca00f..d1f3647 100644
--- a/core/src/Utils/IO/DataStream.hpp
+++ b/core/src/Utils/IO/DataStream.hpp
@@ -8,67 +8,116 @@
 #include <fstream>
 #include <span>
 
-class SerializationStreamProxy
+class BaseDataStream
 {
+private:
+	std::endian mEndian = std::endian::big;
+
+public:
+	std::endian GetEndianness() const;
+	void SetEndianness(std::endian endianness);
+};
+
+class InputDataStream : public BaseDataStream
+{
+private:
+	std::fstream mBackend;
+
 public:
 	static constexpr bool IsSerializer()
 	{
-		return true;
+		return false;
 	}
 
-public:
-	DataStream* Stream;
+	InputDataStream(std::fstream stream);
 
-	template <class T>
-	void Bytes(size_t byteCount, T* buffer) const;
+	void ReadBytes(size_t byteCount, std::byte* buffer);
+	void ReadBytes(size_t byteCount, char* buffer);
+	void ReadBytes(size_t byteCount, signed char* buffer);
+	void ReadBytes(size_t byteCount, unsigned char* buffer);
 
-	template <class T>
-	void Value(T t) const;
+	template <class TInserter>
+	void ReadBytes(size_t byteCount, TInserter&& inserter)
+	{
+		for (size_t i = 0; i < byteCount; ++i) {
+			uint8_t byte;
+			Read(byte);
 
-	template <class T>
-	void Object(T& obj) const;
+			inserter = byte;
+		}
+	}
 
-	template <class TObject, class TAdapter>
-	void ObjectAdapted(TObject& obj, TAdapter&& adapter) const;
-};
+	void Read(int8_t& n);
+	void Read(int16_t& n);
+	void Read(int32_t& n);
+	void Read(int64_t& n);
 
-class DeserializationStreamProxy
-{
-public:
-	static constexpr bool IsSerializer()
+	void Read(uint8_t& n);
+	void Read(uint16_t& n);
+	void Read(uint32_t& n);
+	void Read(uint64_t& n);
+
+	void Read(float& n);
+	void Read(double& n);
+
+	template <class TObject>
+	void ReadObject(TObject& obj)
 	{
-		return false;
+		if constexpr (requires(TObject t) { t.ReadFromDataStream(std::declval<BaseDataStream>()); }) {
+			obj.ReadFromDataStream(*this);
+		} else if constexpr (requires(TObject t) { t.OperateIOProxy(std::declval<DataInputStream>()); }) {
+			obj.OperateIOProxy(*this);
+		} else {
+			static_assert(false && sizeof(TObject), "This type does not have integration with InputDataStream.");
+		}
+	}
+
+	template <class TObject, class TAdapter>
+	void ReadObjectAdapted(TObject& obj, TAdapter&& adapter)
+	{
+		adapter.ReadFromDataStream(*this, obj);
 	}
 
 public:
-	DataStream* Stream;
+	// Proxy functions for OperateIOProxy
 
 	template <class T>
-	void Bytes(size_t byteCount, T* buffer) const;
+	void Bytes(size_t byteCount, T* buffer) const
+	{
+		ReadBytes(byteCount, buffer);
+	}
 
 	template <class T>
-	void Value(T& t) const;
+	void Value(T& t) const
+	{
+		Read(t);
+	}
 
 	template <class T>
-	void Object(T& obj) const;
+	void Object(T& obj) const
+	{
+		ReadObject(obj);
+	}
 
 	template <class TObject, class TAdapter>
-	void ObjectAdapted(TObject& obj, TAdapter&& adapter) const;
+	void ObjectAdapted(TObject& obj, TAdapter&& adapter) const
+	{
+		ReadObjectAdapted(obj, adapter);
+	}
 };
 
-class DataStream
+class OutputDataStream : public BaseDataStream
 {
 private:
-	// TODO customizable storage lik QIODevice
-	// TODO move read/write into separate classes, removing need of IOAdapters?
 	std::fstream mBackend;
-	std::endian mEndian;
 
 public:
-	DataStream(std::fstream stream);
+	static constexpr bool IsSerializer()
+	{
+		return true;
+	}
 
-	std::endian GetEndianness() const;
-	void SetEndianness(std::endian endianness);
+	OutputDataStream(std::fstream stream);
 
 	void WriteBytes(size_t byteCount, const std::byte* buffer);
 	void WriteBytes(size_t byteCount, const char* buffer);
@@ -84,58 +133,28 @@ public:
 		}
 	}
 
-	void ReadBytes(size_t byteCount, std::byte* buffer);
-	void ReadBytes(size_t byteCount, char* buffer);
-	void ReadBytes(size_t byteCount, signed char* buffer);
-	void ReadBytes(size_t byteCount, unsigned char* buffer);
-
-	template <class TInserter>
-	void ReadBytes(size_t byteCount, TInserter&& inserter)
-	{
-		for (size_t i = 0; i < byteCount; ++i) {
-			uint8_t byte;
-			Read(byte);
-
-			inserter = byte;
-		}
-	}
-
 	void Write(int8_t n);
 	void Write(int16_t n);
 	void Write(int32_t n);
 	void Write(int64_t n);
 
-	void Read(int8_t& n);
-	void Read(int16_t& n);
-	void Read(int32_t& n);
-	void Read(int64_t& n);
-
 	void Write(uint8_t n);
 	void Write(uint16_t n);
 	void Write(uint32_t n);
 	void Write(uint64_t n);
 
-	void Read(uint8_t& n);
-	void Read(uint16_t& n);
-	void Read(uint32_t& n);
-	void Read(uint64_t& n);
-
 	void Write(float n);
 	void Write(double n);
 
-	void Read(float& n);
-	void Read(double& n);
-
 	template <class TObject>
 	void WriteObject(TObject& obj)
 	{
-		if constexpr (requires(TObject t) { t.WriteToDataStream(std::declval<DataStream>()); }) {
+		if constexpr (requires(TObject t) { t.WriteToDataStream(std::declval<BaseDataStream>()); }) {
 			obj.WriteToDataStream(*this);
-		} else if constexpr (requires(TObject t) { t.OperateIOProxy(std::declval<SerializationStreamProxy>()); }) {
-			SerializationStreamProxy adapter{ this };
-			obj.OperateIOProxy(adapter);
+		} else if constexpr (requires(TObject t) { t.OperateIOProxy(std::declval<DataOutputStream>()); }) {
+			obj.OperateIOProxy(*this);
 		} else {
-			static_assert(false && sizeof(TObject), "This type does not have integration with DataStream.");
+			static_assert(false && sizeof(TObject), "This type does not have integration with OutputDataStream.");
 		}
 	}
 
@@ -145,70 +164,30 @@ public:
 		adapter.WriteToDataStream(*this, obj);
 	}
 
-	template <class TObject>
-	void ReadObject(TObject& obj)
+public:
+	// Proxy functions for OperateIOProxy
+
+	template <class T>
+	void Bytes(size_t byteCount, T* buffer) const
 	{
-		if constexpr (requires(TObject t) { t.ReadFromDataStream(std::declval<DataStream>()); }) {
-			obj.ReadFromDataStream(*this);
-		} else if constexpr (requires(TObject t) { t.OperateIOProxy(std::declval<DeserializationStreamProxy>()); }) {
-			DeserializationStreamProxy adapter{ this };
-			obj.OperateIOProxy(adapter);
-		} else {
-			static_assert(false && sizeof(TObject), "This type does not have integration with DataStream.");
-		}
+		WriteBytes(byteCount, buffer);
 	}
 
-	template <class TObject, class TAdapter>
-	void ReadObjectAdapted(TObject& obj, TAdapter&& adapter)
+	template <class T>
+	void Value(T t) const
 	{
-		adapter.ReadFromDataStream(*this, obj);
+		Write(t);
 	}
-};
-
-template <class T>
-void SerializationStreamProxy::Bytes(size_t byteCount, T* buffer) const
-{
-	Stream->WriteBytes(byteCount, buffer);
-}
-
-template <class T>
-void SerializationStreamProxy::Value(T t) const
-{
-	Stream->Write(t);
-}
 
-template <class T>
-void SerializationStreamProxy::Object(T& obj) const
-{
-	Stream->WriteObject(obj);
-}
-
-template <class TObject, class TAdapter>
-void SerializationStreamProxy::ObjectAdapted(TObject& obj, TAdapter&& adapter) const
-{
-	Stream->WriteObjectAdapted(obj, adapter);
-}
-
-template <class T>
-void DeserializationStreamProxy::Bytes(size_t byteCount, T* buffer) const
-{
-	Stream->WriteBytes(byteCount, buffer);
-}
-
-template <class T>
-void DeserializationStreamProxy::Value(T& t) const
-{
-	Stream->Read(t);
-}
-
-template <class T>
-void DeserializationStreamProxy::Object(T& obj) const
-{
-	Stream->ReadObject(obj);
-}
+	template <class T>
+	void Object(T& obj) const
+	{
+		WriteObject(obj);
+	}
 
-template <class TObject, class TAdapter>
-void DeserializationStreamProxy::ObjectAdapted(TObject& obj, TAdapter&& adapter) const
-{
-	Stream->ReadObjectAdapted(obj, adapter);
-}
+	template <class TObject, class TAdapter>
+	void ObjectAdapted(TObject& obj, TAdapter&& adapter) const
+	{
+		WriteObjectAdapted(obj, adapter);
+	}
+};