8 files changed, 276 insertions, 312 deletions

diff --git a/core/src/Utils/IO/Archive.cpp b/core/src/Utils/IO/Archive.cpp
index 559c476..b6f806b 100644
--- a/core/src/Utils/IO/Archive.cpp
+++ b/core/src/Utils/IO/Archive.cpp
@@ -10,23 +10,9 @@ constexpr uint8_t kByteOrderMark = []() {
 	}
 }();
 
-std::optional<DataArchive> DataArchive::SaveFile(const std::filesystem::path& path)
+std::optional<InputDataStream> DataArchive::LoadFile(const std::filesystem::path& path)
 {
-	auto archive = DataArchive(DataStream(std::fstream(path)));
-	auto& stream = archive.mStream;
-
-	stream.WriteBytes(kMagicNumberCount, kMagicNumbers);
-	stream.Write(kByteOrderMark);
-
-	stream.SetEndianness(std::endian::native);
-
-	return archive;
-}
-
-std::optional<DataArchive> DataArchive::LoadFile(const std::filesystem::path& path)
-{
-	auto archive = DataArchive(DataStream(std::fstream(path)));
-	auto& stream = archive.mStream;
+	auto stream = InputDataStream(std::fstream(path));
 
 	uint8_t magicNumbers[kMagicNumberCount];
 	stream.ReadBytes(kMagicNumberCount, magicNumbers);
@@ -46,20 +32,17 @@ std::optional<DataArchive> DataArchive::LoadFile(const std::filesystem::path& pa
 		default: std::abort();
 	}
 
-	return archive;
+	return stream;
 }
 
-const DataStream& DataArchive::GetStream() const
+std::optional<OutputDataStream> DataArchive::SaveFile(const std::filesystem::path& path)
 {
-	return mStream;
-}
+	auto stream = OutputDataStream(std::fstream(path));
 
-DataStream& DataArchive::GetStream()
-{
-	return mStream;
-}
+	stream.WriteBytes(kMagicNumberCount, kMagicNumbers);
+	stream.Write(kByteOrderMark);
 
-DataArchive::DataArchive(DataStream stream)
-	: mStream(std::move(stream))
-{
+	stream.SetEndianness(std::endian::native);
+
+	return stream;
 }
diff --git a/core/src/Utils/IO/Archive.hpp b/core/src/Utils/IO/Archive.hpp
index 72f79c6..28e7c99 100644
--- a/core/src/Utils/IO/Archive.hpp
+++ b/core/src/Utils/IO/Archive.hpp
@@ -7,16 +7,8 @@
 
 class DataArchive
 {
-private:
-	DataStream mStream;
-
 public:
-	static std::optional<DataArchive> SaveFile(const std::filesystem::path& path);
-	static std::optional<DataArchive> LoadFile(const std::filesystem::path& path);
-
-	const DataStream& GetStream()const;
-	DataStream& GetStream();
-
-private:
-	DataArchive(DataStream stream);
+	// TODO more complete impl
+	static std::optional<InputDataStream> LoadFile(const std::filesystem::path& path);
+	static std::optional<OutputDataStream> SaveFile(const std::filesystem::path& path);
 };
diff --git a/core/src/Utils/IO/DataStream.cpp b/core/src/Utils/IO/DataStream.cpp
index 4880901..7fee881 100644
--- a/core/src/Utils/IO/DataStream.cpp
+++ b/core/src/Utils/IO/DataStream.cpp
@@ -2,78 +2,23 @@
 
 #include <bit>
 #include <limits>
+#include <utility>
 
 static_assert(std::numeric_limits<float>::is_iec559, "Non IEE754/IEC559 'float' is not supported.");
 static_assert(std::numeric_limits<double>::is_iec559, "Non IEE754/IEC559 'double' is not supported.");
 
 static_assert(std::endian::native == std::endian::little || std::endian::native == std::endian::big, "Mixed endian is not supported.");
 
-DataStream::DataStream(std::fstream stream)
-	: mBackend{ std::move(stream) }
-	, mEndian{ std::endian::big }
-{
-}
-
-std::endian DataStream::GetEndianness() const
-{
-	return mEndian;
-}
-
-void DataStream::SetEndianness(std::endian endianness)
-{
-	mEndian = endianness;
-}
-
-void DataStream::ReadBytes(size_t byteCount, std::byte* buffer)
-{
-	mBackend.read(reinterpret_cast<char*>(buffer), static_cast<std::streamsize>(byteCount));
-}
-
-void DataStream::ReadBytes(size_t byteCount, char* buffer)
-{
-	mBackend.read(reinterpret_cast<char*>(buffer), static_cast<std::streamsize>(byteCount));
-}
-
-void DataStream::ReadBytes(size_t byteCount, signed char* buffer)
-{
-	mBackend.read(reinterpret_cast<char*>(buffer), static_cast<std::streamsize>(byteCount));
-}
-
-void DataStream::ReadBytes(size_t byteCount, unsigned char* buffer)
-{
-	mBackend.read(reinterpret_cast<char*>(buffer), static_cast<std::streamsize>(byteCount));
-}
-
-void DataStream::WriteBytes(size_t byteCount, const std::byte* buffer)
-{
-	mBackend.write(reinterpret_cast<const char*>(buffer), static_cast<std::streamsize>(byteCount));
-}
-
-void DataStream::WriteBytes(size_t byteCount, const char* buffer)
-{
-	mBackend.write(reinterpret_cast<const char*>(buffer), static_cast<std::streamsize>(byteCount));
-}
-
-void DataStream::WriteBytes(size_t byteCount, const signed char* buffer)
-{
-	mBackend.write(reinterpret_cast<const char*>(buffer), static_cast<std::streamsize>(byteCount));
-}
-
-void DataStream::WriteBytes(size_t byteCount, const unsigned char* buffer)
-{
-	mBackend.write(reinterpret_cast<const char*>(buffer), static_cast<std::streamsize>(byteCount));
-}
-
 // Reading/writing signed integer byte-by-byte is fine, since the representation got fixed to 2's complements in C++20
 
-uint16_t ByteSwap(uint16_t n)
+static uint16_t ByteSwap(uint16_t n)
 {
 	auto bytes = reinterpret_cast<std::byte*>(n);
 	std::swap(bytes[0], bytes[1]);
 	return n;
 }
 
-uint32_t ByteSwap(uint32_t n)
+static uint32_t ByteSwap(uint32_t n)
 {
 #ifdef _MSC_VER
 	// TODO
@@ -82,7 +27,7 @@ uint32_t ByteSwap(uint32_t n)
 #endif
 }
 
-uint64_t ByteSwap(uint64_t n)
+static uint64_t ByteSwap(uint64_t n)
 {
 #ifdef _MSC_VER
 	// TODO
@@ -92,7 +37,7 @@ uint64_t ByteSwap(uint64_t n)
 }
 
 template <class TSigned>
-TSigned ByteSwap(TSigned n)
+static TSigned ByteSwap(TSigned n)
 {
 	using Unsigned = std::make_unsigned_t<TSigned>;
 
@@ -100,179 +45,239 @@ TSigned ByteSwap(TSigned n)
 	return std::bit_cast<TSigned>(swapped);
 }
 
-void DataStream::Write(int8_t n)
+std::endian BaseDataStream::GetEndianness() const
 {
-	mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+	return mEndian;
 }
 
-void DataStream::Write(int16_t n)
+void BaseDataStream::SetEndianness(std::endian endianness)
 {
-	if (mEndian != std::endian::native) {
-		n = ::ByteSwap(n);
-	}
-	mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+	mEndian = endianness;
 }
 
-void DataStream::Write(int32_t n)
+InputDataStream::InputDataStream(std::fstream stream)
+	: mBackend{ std::move(stream) }
 {
-	if (mEndian != std::endian::native) {
-		n = ::ByteSwap(n);
-	}
-	mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
 }
 
-void DataStream::Write(int64_t n)
+void InputDataStream::ReadBytes(size_t byteCount, std::byte* buffer)
 {
-	if (mEndian != std::endian::native) {
-		n = ::ByteSwap(n);
-	}
-	mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+	mBackend.read(reinterpret_cast<char*>(buffer), static_cast<std::streamsize>(byteCount));
+}
+
+void InputDataStream::ReadBytes(size_t byteCount, char* buffer)
+{
+	mBackend.read(reinterpret_cast<char*>(buffer), static_cast<std::streamsize>(byteCount));
+}
+
+void InputDataStream::ReadBytes(size_t byteCount, signed char* buffer)
+{
+	mBackend.read(reinterpret_cast<char*>(buffer), static_cast<std::streamsize>(byteCount));
+}
+
+void InputDataStream::ReadBytes(size_t byteCount, unsigned char* buffer)
+{
+	mBackend.read(reinterpret_cast<char*>(buffer), static_cast<std::streamsize>(byteCount));
 }
 
-void DataStream::Read(int8_t& n)
+void InputDataStream::Read(int8_t& n)
 {
 	// sizeof() of a reference type yields the size of the reference
 	mBackend.read(reinterpret_cast<char*>(&n), sizeof(n));
 }
 
-void DataStream::Read(int16_t& n)
+void InputDataStream::Read(int16_t& n)
 {
 	int16_t tmp;
 	mBackend.read(reinterpret_cast<char*>(&tmp), sizeof(tmp));
-	if (mEndian != std::endian::native) {
+	if (GetEndianness() != std::endian::native) {
 		n = ::ByteSwap(tmp);
 	} else {
 		n = tmp;
 	}
 }
 
-void DataStream::Read(int32_t& n)
+void InputDataStream::Read(int32_t& n)
 {
 	int32_t tmp;
 	mBackend.read(reinterpret_cast<char*>(&tmp), sizeof(tmp));
-	if (mEndian != std::endian::native) {
+	if (GetEndianness() != std::endian::native) {
 		n = ::ByteSwap(tmp);
 	} else {
 		n = tmp;
 	}
 }
 
-void DataStream::Read(int64_t& n)
+void InputDataStream::Read(int64_t& n)
 {
 	int64_t tmp;
 	mBackend.read(reinterpret_cast<char*>(&tmp), sizeof(tmp));
-	if (mEndian != std::endian::native) {
+	if (GetEndianness() != std::endian::native) {
 		n = ::ByteSwap(tmp);
 	} else {
 		n = tmp;
 	}
 }
 
-void DataStream::Write(uint8_t n)
-{
-	mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
-}
-
-void DataStream::Write(uint16_t n)
-{
-	if (mEndian != std::endian::native) {
-		n = ::ByteSwap(n);
-	}
-	mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
-}
-
-void DataStream::Write(uint32_t n)
-{
-	if (mEndian != std::endian::native) {
-		n = ::ByteSwap(n);
-	}
-	mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
-}
-
-void DataStream::Write(uint64_t n)
-{
-	if (mEndian != std::endian::native) {
-		n = ::ByteSwap(n);
-	}
-	mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
-}
-
-void DataStream::Read(uint8_t& n)
+void InputDataStream::Read(uint8_t& n)
 {
 	mBackend.read(reinterpret_cast<char*>(&n), sizeof(n));
 }
 
-void DataStream::Read(uint16_t& n)
+void InputDataStream::Read(uint16_t& n)
 {
 	uint16_t tmp;
 	mBackend.read(reinterpret_cast<char*>(&tmp), sizeof(tmp));
-	if (mEndian != std::endian::native) {
+	if (GetEndianness() != std::endian::native) {
 		n = ::ByteSwap(tmp);
 	} else {
 		n = tmp;
 	}
 }
 
-void DataStream::Read(uint32_t& n)
+void InputDataStream::Read(uint32_t& n)
 {
 	uint32_t tmp;
 	mBackend.read(reinterpret_cast<char*>(&tmp), sizeof(tmp));
-	if (mEndian != std::endian::native) {
+	if (GetEndianness() != std::endian::native) {
 		n = ::ByteSwap(tmp);
 	} else {
 		n = tmp;
 	}
 }
 
-void DataStream::Read(uint64_t& n)
+void InputDataStream::Read(uint64_t& n)
 {
 	uint64_t tmp;
 	mBackend.read(reinterpret_cast<char*>(&tmp), sizeof(tmp));
-	if (mEndian != std::endian::native) {
+	if (GetEndianness() != std::endian::native) {
 		n = ::ByteSwap(tmp);
 	} else {
 		n = tmp;
 	}
 }
 
-void DataStream::Write(float n)
+void InputDataStream::Read(float& n)
 {
-	auto buffer = std::bit_cast<uint32_t>(n);
-	if (mEndian != std::endian::native) {
+	uint32_t buffer;
+	Read(buffer);
+
+	if (GetEndianness() != std::endian::native) {
 		buffer = ::ByteSwap(buffer);
 	}
-	mBackend.read(reinterpret_cast<char*>(&buffer), sizeof(buffer));
+
+	n = std::bit_cast<float>(buffer);
 }
 
-void DataStream::Write(double n)
+void InputDataStream::Read(double& n)
 {
-	auto buffer = std::bit_cast<uint64_t>(n);
-	if (mEndian != std::endian::native) {
+	uint64_t buffer;
+	Read(buffer);
+
+	if (GetEndianness() != std::endian::native) {
 		buffer = ::ByteSwap(buffer);
 	}
-	mBackend.read(reinterpret_cast<char*>(&buffer), sizeof(buffer));
+
+	n = std::bit_cast<double>(buffer);
 }
 
-void DataStream::Read(float& n)
+OutputDataStream::OutputDataStream(std::fstream stream)
+	: mBackend{ std::move(stream) }
 {
-	uint32_t buffer;
-	Read(buffer);
+}
 
-	if (mEndian != std::endian::native) {
-		buffer = ::ByteSwap(buffer);
+void OutputDataStream::WriteBytes(size_t byteCount, const std::byte* buffer)
+{
+	mBackend.write(reinterpret_cast<const char*>(buffer), static_cast<std::streamsize>(byteCount));
+}
+
+void OutputDataStream::WriteBytes(size_t byteCount, const char* buffer)
+{
+	mBackend.write(reinterpret_cast<const char*>(buffer), static_cast<std::streamsize>(byteCount));
+}
+
+void OutputDataStream::WriteBytes(size_t byteCount, const signed char* buffer)
+{
+	mBackend.write(reinterpret_cast<const char*>(buffer), static_cast<std::streamsize>(byteCount));
+}
+
+void OutputDataStream::WriteBytes(size_t byteCount, const unsigned char* buffer)
+{
+	mBackend.write(reinterpret_cast<const char*>(buffer), static_cast<std::streamsize>(byteCount));
+}
+
+void OutputDataStream::Write(int8_t n)
+{
+	mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+}
+
+void OutputDataStream::Write(int16_t n)
+{
+	if (GetEndianness() != std::endian::native) {
+		n = ::ByteSwap(n);
 	}
+	mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+}
 
-	n = std::bit_cast<float>(buffer);
+void OutputDataStream::Write(int32_t n)
+{
+	if (GetEndianness() != std::endian::native) {
+		n = ::ByteSwap(n);
+	}
+	mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
 }
 
-void DataStream::Read(double& n)
+void OutputDataStream::Write(int64_t n)
 {
-	uint64_t buffer;
-	Read(buffer);
+	if (GetEndianness() != std::endian::native) {
+		n = ::ByteSwap(n);
+	}
+	mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+}
+
+void OutputDataStream::Write(uint8_t n)
+{
+	mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+}
+
+void OutputDataStream::Write(uint16_t n)
+{
+	if (GetEndianness() != std::endian::native) {
+		n = ::ByteSwap(n);
+	}
+	mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+}
 
-	if (mEndian != std::endian::native) {
+void OutputDataStream::Write(uint32_t n)
+{
+	if (GetEndianness() != std::endian::native) {
+		n = ::ByteSwap(n);
+	}
+	mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+}
+
+void OutputDataStream::Write(uint64_t n)
+{
+	if (GetEndianness() != std::endian::native) {
+		n = ::ByteSwap(n);
+	}
+	mBackend.write(reinterpret_cast<const char*>(&n), sizeof(n));
+}
+
+void OutputDataStream::Write(float n)
+{
+	auto buffer = std::bit_cast<uint32_t>(n);
+	if (GetEndianness() != std::endian::native) {
 		buffer = ::ByteSwap(buffer);
 	}
+	mBackend.read(reinterpret_cast<char*>(&buffer), sizeof(buffer));
+}
 
-	n = std::bit_cast<double>(buffer);
+void OutputDataStream::Write(double n)
+{
+	auto buffer = std::bit_cast<uint64_t>(n);
+	if (GetEndianness() != std::endian::native) {
+		buffer = ::ByteSwap(buffer);
+	}
+	mBackend.read(reinterpret_cast<char*>(&buffer), sizeof(buffer));
 }
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);
+	}
+};
diff --git a/core/src/Utils/IO/StringIntegration.hpp b/core/src/Utils/IO/StringIntegration.hpp
index a90ea98..8c5588c 100644
--- a/core/src/Utils/IO/StringIntegration.hpp
+++ b/core/src/Utils/IO/StringIntegration.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "Utils/IO/DataStream.hpp"
+
 #include <iterator>
 #include <string>
 #include <string_view>
@@ -7,7 +9,7 @@
 namespace DataStreamAdapters {
 struct String
 {
-	void ReadFromDataStream(DataStream& s, std::string& str)
+	void ReadFromDataStream(InputDataStream& s, std::string& str)
 	{
 		uint64_t size;
 		s.Read(size);
@@ -17,7 +19,7 @@ struct String
 		s.ReadBytes(size, std::back_inserter(str));
 	}
 
-	void WriteToDataStream(DataStream& s, const std::string& str)
+	void WriteToDataStream(OutputDataStream& s, const std::string& str)
 	{
 		s.Write((uint64_t)str.size());
 		s.WriteBytes(str.size(), str.data());
@@ -26,7 +28,7 @@ struct String
 
 struct StringView
 {
-	void WriteToDataStream(DataStream& s, const std::string_view& str)
+	void WriteToDataStream(OutputDataStream& s, const std::string_view& str)
 	{
 		s.Write((uint64_t)str.size());
 		s.WriteBytes(str.size(), str.data());
diff --git a/core/src/Utils/IO/UuidIntegration.hpp b/core/src/Utils/IO/UuidIntegration.hpp
index b6ca062..605f821 100644
--- a/core/src/Utils/IO/UuidIntegration.hpp
+++ b/core/src/Utils/IO/UuidIntegration.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "Utils/IO/DataStream.hpp"
 #include "Utils/UUID.hpp"
 
 #include <cstddef>
@@ -9,7 +10,7 @@
 namespace DataStreamAdapters {
 struct Uuid
 {
-	void ReadFromDataStream(DataStream& s, uuids::uuid& uuid)
+	void ReadFromDataStream(InputDataStream& s, uuids::uuid& uuid)
 	{
 		uint8_t buffer[16];
 		s.ReadBytes(16, buffer);
@@ -17,7 +18,7 @@ struct Uuid
 		uuid = uuids::uuid(gsl::span<uint8_t, 16>{ buffer });
 	}
 
-	void WriteToDataStream(DataStream& s, const uuids::uuid& uuid)
+	void WriteToDataStream(OutputDataStream& s, const uuids::uuid& uuid)
 	{
 		auto gslSpan = uuid.as_bytes();
 		s.WriteBytes(gslSpan.size(), gslSpan.data());
diff --git a/core/src/Utils/IO/VectorIntegration.hpp b/core/src/Utils/IO/VectorIntegration.hpp
index ff6e3a8..dedbf29 100644
--- a/core/src/Utils/IO/VectorIntegration.hpp
+++ b/core/src/Utils/IO/VectorIntegration.hpp
@@ -1,12 +1,14 @@
 #pragma once
 
+#include "Utils/IO/DataStream.hpp"
+
 #include <vector>
 
 namespace DataStreamAdapters {
 struct Vector
 {
 	template <class TElement>
-	void ReadFromDataStream(DataStream& s, std::vecetor<TElement>& vec)
+	void ReadFromDataStream(InputDataStream& s, std::vecetor<TElement>& vec)
 	{
 		s.Write((uint64_t)vec.size());
 		for (auto& element : vec) {
@@ -15,7 +17,7 @@ struct Vector
 	}
 
 	template <class TElement>
-	void WriteToDataStream(DataStream& s, const std::vecetor<TElement>& vec)
+	void WriteToDataStream(OutputDataStream& s, const std::vecetor<TElement>& vec)
 	{
 		uint64_t size;
 		s >> size;
diff --git a/core/src/Utils/IO/fwd.hpp b/core/src/Utils/IO/fwd.hpp
index f249e34..5bfdb20 100644
--- a/core/src/Utils/IO/fwd.hpp
+++ b/core/src/Utils/IO/fwd.hpp
@@ -3,7 +3,7 @@
 // Archive.hpp
 class DataArchive;
 
-// DataStream.hpp
-class SerializationStreamProxy;
-class DeserializationStreamProxy;
-class DataStream;
+// BaseDataStream.hpp
+class BaseDataStream;
+class InputDataStream;
+class OutputDataStream;