More work on IO adapters (not working)

1 files changed, 143 insertions, 32 deletions

diff --git a/core/src/Utils/IO/DataStream.hpp b/core/src/Utils/IO/DataStream.hpp
index 6babf63..fb736cc 100644
--- a/core/src/Utils/IO/DataStream.hpp
+++ b/core/src/Utils/IO/DataStream.hpp
@@ -1,9 +1,124 @@
 #pragma once
 
+#include "Utils/UUID.hpp"
+#include "cplt_fwd.hpp"
+
+#include <string>
+#include <string_view>
+#include <vector>
+
 #include <cstddef>
 #include <cstdint>
 #include <span>
 
+namespace DataStreamIntegrations {
+template <class TElement>
+void ReadFromDataStream(DataStream& s, std::vector<TElement>& vec);
+template <class TElement>
+void WriteToDataStream(DataStream& s, const std::vector<TElement>& vec);
+
+void ReadFromDataStream(DataStream& s, std::string& str);
+void WriteToDataStream(DataStream& s, const std::string& str);
+
+void WriteToDataStream(DataStream& s, const std::string_view& str);
+
+void ReadFromDataStream(DataStream& s, uuids::uuid& uuid);
+void WriteToDataStream(DataStream& s, const uuids::uuid& uuid);
+
+template <class T>
+void OperateIOAdapter(T&, int);
+} // namespace DataStreamIntegrations
+
+class SerializationAdapter
+{
+public:
+	static constexpr bool IsSerializer()
+	{
+		return true;
+	}
+
+public:
+	DataStream* Stream;
+
+	template <class T>
+	void Bytes(size_t byteCount, T* buffer) const
+	{
+		Stream->WriteBytes(byteCount, buffer);
+	}
+
+	template <class T>
+	void Value(T t) const
+	{
+		Stream->Write(t);
+	}
+
+	template <class T>
+	void Object(T& obj) const
+	{
+		Stream->WriteObject(obj);
+	}
+};
+
+class DeserializationAdapter
+{
+public:
+	static constexpr bool IsSerializer()
+	{
+		return false;
+	}
+
+public:
+	DataStream* Stream;
+
+	template <class T>
+	void Bytes(size_t byteCount, T* buffer) const
+	{
+		Stream->WriteBytes(byteCount, buffer);
+	}
+
+	template <class T>
+	void Value(T& t) const
+	{
+		Stream->Read(t);
+	}
+
+	template <class T>
+	void Object(T& obj) const
+	{
+		Stream->ReadObject(obj);
+	}
+};
+
+namespace DataStreamTraits {
+
+template <class T>
+concept HasMember = requires(T t)
+{
+	t.ReadFromDataStream(std::declval<DataStream>());
+};
+
+template <class T>
+concept HasIOAdapterMember = requires(T t)
+{
+	t.OperateIOAdapter(std::declval<SerializationAdapter>());
+	t.OperateIOAdapter(std::declval<DeserializationAdapter>());
+};
+
+template <class T>
+concept HasExtension = requires(T t)
+{
+	DataStreamIntegrations::ReadFromDataStream(std::declval<DataStream>(), t);
+};
+
+template <class T>
+concept HasIOAdapterExtension = requires(T t)
+{
+	DataStreamIntegrations::OperateIOAdapter(std::declval<SerializationAdapter>(), t);
+	DataStreamIntegrations::OperateIOAdapter(std::declval<DeserializationAdapter>(), t);
+};
+
+} // namespace DataStreamTraits
+
 class DataStream
 {
 public:
@@ -80,44 +195,40 @@ public:
 	void Read(double& n);
 
 	template <class TObject>
-	requires requires(TObject obj)
-	{
-		obj.ReadFromDataStream(std::declval<DataStream>());
-	}
 	void ReadObject(TObject& obj)
 	{
-		obj.ReadFromDataStream(*this);
-	}
-
-	template <class TObject>
-	requires requires(TObject obj)
-	{
-		// Let ADL happen
-		ReadFromDataStream(std::declval<DataStream>(), obj);
-	}
-	void ReadObject(TObject& obj)
-	{
-		ReadFromDataStream(*this, obj);
-	}
-
-	template <class TObject>
-	requires requires(TObject obj)
-	{
-		obj.WriteToDataStream(std::declval<DataStream>());
-	}
-	void WriteObject(TObject& obj)
-	{
-		obj.ReadFromDataStream(*this);
+		using namespace DataStreamTraits;
+		if constexpr (HasMember<TObject>) {
+			obj.ReadFromDataStream(*this);
+		} else if constexpr (HasIOAdapterMember<TObject>) {
+			DeserializationAdapter adapter{ this };
+			obj.OperateIOAdapter(adapter);
+		} else if constexpr (HasExtension<TObject>) {
+			DataStreamIntegrations::ReadFromDataStream(*this, obj);
+		} else if constexpr (HasIOAdapterExtension<TObject>) {
+			DeserializationAdapter adapter{ this };
+			DataStreamIntegrations::OperateIOAdapter(adapter, obj);
+		} else {
+			static_assert(false && sizeof(TObject), "This type does not have integration with DataStream.");
+		}
 	}
 
 	template <class TObject>
-	requires requires(TObject obj)
-	{
-		// Let ADL happen
-		WriteToDataStream(std::declval<DataStream>(), obj);
-	}
 	void WriteObject(TObject& obj)
 	{
-		WriteToDataStream(*this, obj);
+		using namespace DataStreamTraits;
+		if constexpr (HasMember<TObject>) {
+			obj.WriteToDataStream(*this);
+		} else if constexpr (HasIOAdapterMember<TObject>) {
+			SerializationAdapter adapter{ this };
+			obj.OperateIOAdapter(adapter);
+		} else if constexpr (HasExtension<TObject>) {
+			DataStreamIntegrations::WriteToDataStream(*this, obj);
+		} else if constexpr (HasIOAdapterExtension<TObject>) {
+			SerializationAdapter adapter{ this };
+			DataStreamIntegrations::OperateIOAdapter(adapter, obj);
+		} else {
+			static_assert(false && sizeof(TObject), "This type does not have integration with DataStream.");
+		}
 	}
 };