From bce37f59df17c2381057086e581b214b2d165c41 Mon Sep 17 00:00:00 2001
From: Persson-dev <sim16.prib@gmail.com>
Date: Thu, 31 Jul 2025 15:01:37 +0200
Subject: [PATCH] allow message serialization through DataBuffer

---
 include/sp/common/DataBuffer.h   | 198 +-----------------------------
 include/sp/common/DataBuffer.inl | 201 +++++++++++++++++++++++++++++++
 include/sp/io/MessageSerialize.h |  47 ++++++++
 3 files changed, 250 insertions(+), 196 deletions(-)
 create mode 100644 include/sp/common/DataBuffer.inl
 create mode 100644 include/sp/io/MessageSerialize.h

diff --git a/include/sp/common/DataBuffer.h b/include/sp/common/DataBuffer.h
index 3d33a43..8b5af48 100644
--- a/include/sp/common/DataBuffer.h
+++ b/include/sp/common/DataBuffer.h
@@ -84,97 +84,6 @@ class DataBuffer {
 	 */
 	DataBuffer& operator<<(const DataBuffer& data);
 
-	/**
-	 * \brief Append a pointer to the buffer
-	 * \param data The data to append
-	 */
-	template <typename T>
-	DataBuffer& operator<<(const std::shared_ptr<T>& data) {
-		return *this << *data;
-	}
-
-	/**
-	 * \brief Append a pointer to the buffer
-	 * \param data The data to append
-	 */
-	template <typename T>
-	DataBuffer& operator<<(const std::unique_ptr<T>& data) {
-		return *this << *data;
-	}
-
-	/**
-	 * \brief Append a vector to the buffer by first writing the size
-	 * \param data The vector to append
-	 */
-	template <typename T>
-	DataBuffer& operator<<(const std::vector<T>& data) {
-		*this << VarInt{data.size()};
-		for (const auto& element : data) {
-			*this << element;
-		}
-		return *this;
-	}
-
-	/**
-	 * \brief Append a list to the buffer by first writing the size
-	 * \param data The list to append
-	 */
-	template <typename T>
-	DataBuffer& operator<<(const std::list<T>& data) {
-		*this << VarInt{data.size()};
-		for (const auto& element : data) {
-			*this << element;
-		}
-		return *this;
-	}
-
-	/**
-	 * \brief Append a map to the buffer by first writing the size
-	 * \param data The map to append
-	 */
-	template <typename K, typename V>
-	DataBuffer& operator<<(const std::map<K, V>& data) {
-		*this << VarInt{data.size()};
-		for (const auto& [key, value] : data) {
-			*this << key << value;
-		}
-		return *this;
-	}
-
-	/**
-	 * \brief Append a map to the buffer by first writing the size
-	 * \param data The map to append
-	 */
-	template <typename K, typename V>
-	DataBuffer& operator<<(const std::unordered_map<K, V>& data) {
-		*this << VarInt{data.size()};
-		for (const auto& [key, value] : data) {
-			*this << key << value;
-		}
-		return *this;
-	}
-
-	/**
-	 * \brief Append a pair to the buffer
-	 * \param data The pair to append
-	 */
-	template <typename K, typename V>
-	DataBuffer& operator<<(const std::pair<K, V>& data) {
-		return *this << data.first << data.second;
-	}
-
-	/**
-	 * \brief Append an array to the buffer by first writing the size
-	 * \param data The buffer to append
-	 */
-	template <typename T, std::size_t Size>
-	DataBuffer& operator<<(const std::array<T, Size>& data) {
-		for (const auto& element : data) {
-			*this << element;
-		}
-		return *this;
-	}
-
 	/**
 	 * \brief Read data into a_Data
 	 * \warning No endian checks
@@ -209,111 +118,6 @@ class DataBuffer {
 	 */
 	DataBuffer& operator>>(std::string& str);
 
-	/**
-	 * \brief Read a pointer
-	 */
-	template <typename T>
-	DataBuffer& operator>>(std::shared_ptr<T>& data) {
-		data = std::make_shared<T>();
-		return *this >> *data;
-	}
-
-	/**
-	 * \brief Read a pointer
-	 */
-	template <typename T>
-	DataBuffer& operator>>(std::unique_ptr<T>& data) {
-		data = std::make_unique<T>();
-		return *this >> *data;
-	}
-
-	/**
-	 * \brief Read a vector (size + data) from the buffer
-	 * \pre The vector is assumed to be empty
-	 */
-	template <typename T>
-	DataBuffer& operator>>(std::vector<T>& data) {
-		VarInt arraySize;
-		*this >> arraySize;
-		for (std::size_t i = 0; i < arraySize.GetValue(); i++) {
-			T newElement;
-			*this >> newElement;
-			data.push_back(newElement);
-		}
-		return *this;
-	}
-
-	/**
-	 * \brief Read a list (size + data) from the buffer
-	 * \pre The list is assumed to be empty
-	 */
-	template <typename T>
-	DataBuffer& operator>>(std::list<T>& data) {
-		VarInt arraySize;
-		*this >> arraySize;
-		for (std::size_t i = 0; i < arraySize.GetValue(); i++) {
-			T newElement;
-			*this >> newElement;
-			data.push_back(newElement);
-		}
-		return *this;
-	}
-
-	/**
-	 * \brief Read a map (size + data) from the buffer
-	 * \pre The map is assumed to be empty
-	 */
-	template <typename K, typename V>
-	DataBuffer& operator>>(std::map<K, V>& data) {
-		VarInt mapSize;
-		*this >> mapSize;
-		for (std::size_t i = 0; i < mapSize.GetValue(); i++) {
-			K newKey;
-			V newValue;
-			*this >> newKey >> newValue;
-			data.emplace(newKey, newValue);
-		}
-		return *this;
-	}
-
-	/**
-	 * \brief Read a map (size + data) from the buffer
-	 * \pre The map is assumed to be empty
-	 */
-	template <typename K, typename V>
-	DataBuffer& operator>>(std::unordered_map<K, V>& data) {
-		VarInt mapSize;
-		*this >> mapSize;
-		for (std::size_t i = 0; i < mapSize.GetValue(); i++) {
-			K newKey;
-			V newValue;
-			*this >> newKey >> newValue;
-			data.emplace(newKey, newValue);
-		}
-		return *this;
-	}
-
-	/**
-	 * \brief Read a pair
-	 */
-	template <typename K, typename V>
-	DataBuffer& operator>>(std::pair<K, V>& data) {
-		return *this >> data.first >> data.second;
-	}
-
-	/**
-	 * \brief Read an array from the buffer
-	 */
-	template <std::size_t Size, typename T>
-	DataBuffer& operator>>(std::array<T, Size>& data) {
-		for (std::size_t i = 0; i < Size; i++) {
-			T newElement;
-			*this >> newElement;
-			data[i] = newElement;
-		}
-		return *this;
-	}
-
 	/**
 	 * \brief Write some data to the buffer
 	 * \param buffer The buffer to write
@@ -459,3 +263,5 @@ class DataBuffer {
 std::ostream& operator<<(std::ostream& os, const DataBuffer& buffer);
 
 }  // namespace sp
+
+#include "DataBuffer.inl"
\ No newline at end of file
diff --git a/include/sp/common/DataBuffer.inl b/include/sp/common/DataBuffer.inl
new file mode 100644
index 0000000..f8dead8
--- /dev/null
+++ b/include/sp/common/DataBuffer.inl
@@ -0,0 +1,201 @@
+#pragma once
+
+namespace sp {
+
+/**
+ * \brief Append a pointer to the buffer
+ * \param data The data to append
+ */
+template <typename T, typename = typename std::enable_if_t<!std::is_abstract_v<T>>>
+DataBuffer& operator<<(DataBuffer& buffer, const std::shared_ptr<T>& data) {
+	return buffer << *data;
+}
+
+/**
+ * \brief Append a pointer to the buffer
+ * \param data The data to append
+ */
+template <typename T, typename = typename std::enable_if_t<!std::is_abstract_v<T>>>
+DataBuffer& operator<<(DataBuffer& buffer, const std::unique_ptr<T>& data) {
+	return buffer << *data;
+}
+
+/**
+ * \brief Append a vector to the buffer by first writing the size
+ * \param data The vector to append
+ */
+template <typename T>
+DataBuffer& operator<<(DataBuffer& buffer, const std::vector<T>& data) {
+	buffer << VarInt{data.size()};
+	for (const auto& element : data) {
+		buffer << element;
+	}
+	return buffer;
+}
+
+/**
+ * \brief Append a list to the buffer by first writing the size
+ * \param data The list to append
+ */
+template <typename T>
+DataBuffer& operator<<(DataBuffer& buffer, const std::list<T>& data) {
+	buffer << VarInt{data.size()};
+	for (const auto& element : data) {
+		buffer << element;
+	}
+	return buffer;
+}
+
+/**
+ * \brief Append a map to the buffer by first writing the size
+ * \param data The map to append
+ */
+template <typename K, typename V>
+DataBuffer& operator<<(DataBuffer& buffer, const std::map<K, V>& data) {
+	buffer << VarInt{data.size()};
+	for (const auto& [key, value] : data) {
+		buffer << key << value;
+	}
+	return buffer;
+}
+
+/**
+ * \brief Append a map to the buffer by first writing the size
+ * \param data The map to append
+ */
+template <typename K, typename V>
+DataBuffer& operator<<(DataBuffer& buffer, const std::unordered_map<K, V>& data) {
+	buffer << VarInt{data.size()};
+	for (const auto& [key, value] : data) {
+		buffer << key << value;
+	}
+	return buffer;
+}
+
+/**
+ * \brief Append a pair to the buffer
+ * \param data The pair to append
+ */
+template <typename K, typename V>
+DataBuffer& operator<<(DataBuffer& buffer, const std::pair<K, V>& data) {
+	return buffer << data.first << data.second;
+}
+
+/**
+ * \brief Append an array to the buffer by first writing the size
+ * \param data The buffer to append
+ */
+template <typename T, std::size_t Size>
+DataBuffer& operator<<(DataBuffer& buffer, const std::array<T, Size>& data) {
+	for (const auto& element : data) {
+		buffer << element;
+	}
+	return buffer;
+}
+
+/**
+ * \brief Read a pointer
+ */
+template <typename T, typename = typename std::enable_if_t<!std::is_abstract_v<T>>>
+DataBuffer& operator>>(DataBuffer& buffer, std::shared_ptr<T>& data) {
+	data = std::make_shared<T>();
+	return buffer >> *data;
+}
+
+/**
+ * \brief Read a pointer
+ */
+template <typename T, typename = typename std::enable_if_t<!std::is_abstract_v<T>>>
+DataBuffer& operator>>(DataBuffer& buffer, std::unique_ptr<T>& data) {
+	data = std::make_unique<T>();
+	return buffer >> *data;
+}
+
+/**
+ * \brief Read a vector (size + data) from the buffer
+ * \pre The vector is assumed to be empty
+ */
+template <typename T>
+DataBuffer& operator>>(DataBuffer& buffer, std::vector<T>& data) {
+	VarInt arraySize;
+	buffer >> arraySize;
+	for (std::size_t i = 0; i < arraySize.GetValue(); i++) {
+		T newElement;
+		buffer >> newElement;
+		data.push_back(newElement);
+	}
+	return buffer;
+}
+
+/**
+ * \brief Read a list (size + data) from the buffer
+ * \pre The list is assumed to be empty
+ */
+template <typename T>
+DataBuffer& operator>>(DataBuffer& buffer, std::list<T>& data) {
+	VarInt arraySize;
+	buffer >> arraySize;
+	for (std::size_t i = 0; i < arraySize.GetValue(); i++) {
+		T newElement;
+		buffer >> newElement;
+		data.push_back(newElement);
+	}
+	return buffer;
+}
+
+/**
+ * \brief Read a map (size + data) from the buffer
+ * \pre The map is assumed to be empty
+ */
+template <typename K, typename V>
+DataBuffer& operator>>(DataBuffer& buffer, std::map<K, V>& data) {
+	VarInt mapSize;
+	buffer >> mapSize;
+	for (std::size_t i = 0; i < mapSize.GetValue(); i++) {
+		K newKey;
+		V newValue;
+		buffer >> newKey >> newValue;
+		data.emplace(newKey, newValue);
+	}
+	return buffer;
+}
+
+/**
+ * \brief Read a map (size + data) from the buffer
+ * \pre The map is assumed to be empty
+ */
+template <typename K, typename V>
+DataBuffer& operator>>(DataBuffer& buffer, std::unordered_map<K, V>& data) {
+	VarInt mapSize;
+	buffer >> mapSize;
+	for (std::size_t i = 0; i < mapSize.GetValue(); i++) {
+		K newKey;
+		V newValue;
+		buffer >> newKey >> newValue;
+		data.emplace(newKey, newValue);
+	}
+	return buffer;
+}
+
+/**
+ * \brief Read a pair
+ */
+template <typename K, typename V>
+DataBuffer& operator>>(DataBuffer& buffer, std::pair<K, V>& data) {
+	return buffer >> data.first >> data.second;
+}
+
+/**
+ * \brief Read an array from the buffer
+ */
+template <std::size_t Size, typename T>
+DataBuffer& operator>>(DataBuffer& buffer, std::array<T, Size>& data) {
+	for (std::size_t i = 0; i < Size; i++) {
+		T newElement;
+		buffer >> newElement;
+		data[i] = newElement;
+	}
+	return buffer;
+}
+
+}  // namespace sp
\ No newline at end of file
diff --git a/include/sp/io/MessageSerialize.h b/include/sp/io/MessageSerialize.h
new file mode 100644
index 0000000..035227a
--- /dev/null
+++ b/include/sp/io/MessageSerialize.h
@@ -0,0 +1,47 @@
+#pragma once
+
+#include <sp/protocol/MessageFactory.h>
+
+namespace sp {
+
+template <typename TMessageID, typename THandler>
+DataBuffer& operator<<(DataBuffer& a_Buffer, const std::unique_ptr<MessageBase<TMessageID, THandler>>& a_Message) {
+	return a_Buffer << VarInt{static_cast<std::uint64_t>(a_Message->GetId())} << a_Message->Write();
+}
+
+template <typename TMessageID, typename THandler>
+DataBuffer& operator<<(DataBuffer& a_Buffer, const std::shared_ptr<MessageBase<TMessageID, THandler>>& a_Message) {
+	return a_Buffer << VarInt{static_cast<std::uint64_t>(a_Message->GetId())} << a_Message->Write();
+}
+
+template <typename TMessageID, typename THandler, typename TTMessages>
+DataBuffer& operator>>(DataBuffer& a_Buffer, std::unique_ptr<MessageBase<TMessageID, THandler>>& a_Message) {
+	using TBase = MessageBase<TMessageID, THandler>;
+	using MsgId = typename TBase::MessageIdType;
+	static MessageFactory<TBase, TTMessages> factory;
+
+	VarInt msgId;
+	a_Buffer >> msgId;
+
+	a_Message = factory.CreateMessage(MsgId(msgId.GetValue()));
+	a_Message->Read(a_Buffer);
+
+	return a_Buffer;
+}
+
+template <typename TMessageID, typename THandler, typename TTMessages>
+DataBuffer& operator>>(DataBuffer& a_Buffer, std::shared_ptr<MessageBase<TMessageID, THandler>>& a_Message) {
+	using TBase = MessageBase<TMessageID, THandler>;
+	using MsgId = typename TBase::MessageIdType;
+	static MessageFactory<TBase, TTMessages> factory;
+
+	VarInt msgId;
+	a_Buffer >> msgId;
+
+	a_Message = std::shared_ptr<TBase>(factory.CreateMessage(MsgId(msgId.GetValue())).release());
+	a_Message->Read(a_Buffer);
+
+	return a_Buffer;
+}
+
+}  // namespace sp
\ No newline at end of file