begin ssl support

Reviewed-on: #10
Co-authored-by: Persson-dev <sim16.prib@gmail.com>
Co-committed-by: Persson-dev <sim16.prib@gmail.com>

.github/workflows/ubuntu.yml

@@ -0,0 +1,31 @@
+name: Linux arm64
+run-name: Build And Test
+
+on: [push]
+
+
+env:
+  XMAKE_ROOT: y
+
+jobs:
+  Build:
+    runs-on: ubuntu-latest
+    steps: 
+      - name: Check out repository code
+        uses: actions/checkout@v3
+
+      - name: Prepare XMake
+        uses: xmake-io/github-action-setup-xmake@v1
+        with:
+          xmake-version: latest
+          actions-cache-folder: '.xmake-cache'
+          actions-cache-key: 'ubuntu'
+      
+      - name: XMake config
+        run: xmake f -p linux -y
+
+      - name: Build
+        run: xmake
+
+      - name: Test
+        run: xmake test

README.md

@@ -0,0 +1,10 @@
+# SimpleProtocolLib
+
+Network engine used to (mainly) communicate with packets 
+
+# Integrate with xmake
+
+```lua
+add_repositories("persson-repo https://git.ale-pri.com/Persson-dev/xmake-repo.git")
+add_requires("splib", { debug = is_mode("debug") })
+```

include/examples/DisconnectPacket.h

@@ -4,7 +4,7 @@
 #include <sp/protocol/Field.h>
 #include <sp/protocol/MessageBase.h>
 
-enum DisconnectPacketFields { 
+enum class DisconnectFieldsE { 
 	Reason = 0 
 };
 
@@ -15,6 +15,6 @@ DeclarePacket(Disconnect){
     PacketConstructor(Disconnect)
 
 	const std::string& GetReason() const {
-		return GetField<Reason>();
+		return GetField<DisconnectFieldsE, DisconnectFieldsE::Reason>();
 	}
 };

include/examples/KeepAlivePacket.h

@@ -4,9 +4,8 @@
 #include <sp/protocol/Field.h>
 #include <sp/protocol/MessageBase.h>
 
-enum KeepAlivePacketFields {
+enum class KeepAliveFieldsE {
 	KeepAliveId = 0,
-	TestAlignField = 1,
 };
 
 using KeepAliveFields = std::tuple<
@@ -18,6 +17,6 @@ DeclarePacket(KeepAlive){
 	PacketConstructor(KeepAlive)
 
 	std::uint64_t GetKeepAliveId() const {
-		return GetField<KeepAlive>();
+		return GetField<KeepAliveFieldsE, KeepAliveFieldsE::KeepAliveId>();
 	}
 };

include/examples/PacketExample.h

@@ -6,12 +6,13 @@ enum PacketId {
 	UpgradeTower,
 };
 
-#include <examples/KeepAlivePacket.h>
 #include <examples/DisconnectPacket.h>
+#include <examples/KeepAlivePacket.h>
 #include <examples/UpgradeTowerPacket.h>
 
 // they must be in the same order as in the enum !
 using AllPackets = std::tuple<KeepAlivePacket, DisconnectPacket, UpgradeTowerPacket>;
 
-#include <sp/default/DefaultPacketHandler.h>
+#include <sp/default/DefaultPacketDispatcher.h>
 #include <sp/default/DefaultPacketFactory.h>
+#include <sp/default/DefaultPacketHandler.h>

include/examples/UpgradeTowerPacket.h

@@ -4,7 +4,8 @@
 #include <sp/protocol/Field.h>
 #include <sp/protocol/MessageBase.h>
 
-enum UpgradeTowerPacketFields {
+
+enum class UpgradeTowerFieldsE {
 	m_Tower = 0,
 	m_Upgrade,
 };
@@ -21,10 +22,10 @@ DeclarePacket(UpgradeTower){
 	PacketConstructor(UpgradeTower)
 
 	std::uint16_t GetTowerId() const {
-		return GetField<0>().GetField<m_Tower>();
+		return GetField<0>().GetField<UpgradeTowerFieldsE, UpgradeTowerFieldsE::m_Tower>();
 	}
 
 	std::uint8_t GetTowerUpgrade() const {
-		return GetField<0>().GetField<m_Upgrade>();
+		return GetField<0>().GetField<UpgradeTowerFieldsE, UpgradeTowerFieldsE::m_Upgrade>();
 	}
 };

include/sp/common/ByteSwapping.h

@@ -1,26 +1,10 @@
 #pragma once
 
-#ifdef _WIN32
-#include <winsock2.h>
-#else
-#include <arpa/inet.h>
-#endif
-
 #include <cstdint>
 
 namespace sp {
 
-template <typename T>
+bool IsSystemBigEndian();
-void SwapBytes(T& value) {
-	char* ptr = reinterpret_cast<char*>(&value);
-	std::reverse(ptr, ptr + sizeof(T));
-}
-
-bool IsSystemBigEndian() {
-	static constexpr std::uint16_t test = 10;
-	static const bool isBigEndian = reinterpret_cast<const std::uint8_t*>(&test)[1] == 10;
-	return isBigEndian;
-}
 
 /**
  * \brief Serialize value to (network byte order) big endian
@@ -29,21 +13,13 @@ template <typename T>
 void ToNetwork(T& value) {}
 
 template <>
-void ToNetwork<std::uint16_t>(std::uint16_t& value) {
+void ToNetwork<std::uint16_t>(std::uint16_t& value);
-	value = htons(value);
-}
 
 template <>
-void ToNetwork<std::uint32_t>(std::uint32_t& value) {
+void ToNetwork<std::uint32_t>(std::uint32_t& value);
-	value = htonl(value);
-}
 
 template <>
-void ToNetwork<std::uint64_t>(std::uint64_t& value) {
+void ToNetwork<std::uint64_t>(std::uint64_t& value);
-	if (IsSystemBigEndian())
-		return;
-	SwapBytes(value);
-}
 
 /**
  * \brief Deserialize value from (network byte order) big endian
@@ -52,21 +28,13 @@ template <typename T>
 void FromNetwork(T& value) {}
 
 template <>
-void FromNetwork<std::uint16_t>(std::uint16_t& value) {
+void FromNetwork<std::uint16_t>(std::uint16_t& value);
-	value = ntohs(value);
-}
 
 template <>
-void FromNetwork<std::uint32_t>(std::uint32_t& value) {
+void FromNetwork<std::uint32_t>(std::uint32_t& value);
-	value = ntohl(value);
-}
 
 template <>
-void FromNetwork<std::uint64_t>(std::uint64_t& value) {
+void FromNetwork<std::uint64_t>(std::uint64_t& value);
-	if (IsSystemBigEndian())
-		return;
-	SwapBytes(value);
-}
 
 /**
  * \brief Swap bytes if the value is any kind of integer
@@ -75,18 +43,12 @@ template <typename T>
 void TrySwapBytes(T& value) {}
 
 template <>
-void TrySwapBytes<std::uint16_t>(std::uint16_t& value) {
+void TrySwapBytes<std::uint16_t>(std::uint16_t& value);
-	SwapBytes(value);
-}
 
 template <>
-void TrySwapBytes<std::uint32_t>(std::uint32_t& value) {
+void TrySwapBytes<std::uint32_t>(std::uint32_t& value);
-	SwapBytes(value);
-}
 
 template <>
-void TrySwapBytes<std::uint64_t>(std::uint64_t& value) {
+void TrySwapBytes<std::uint64_t>(std::uint64_t& value);
-	SwapBytes(value);
-}
 
 }  // namespace sp

include/sp/common/DataBuffer.h

@@ -13,6 +13,7 @@
 #include <string>
 #include <sp/common/VarInt.h>
 #include <vector>
+#include <map>
 
 namespace sp {
 
@@ -88,6 +89,19 @@ class DataBuffer {
 		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& element : data) {
+			*this << element.first << element.second;
+		}
+		return *this;
+	}
+
 	/**
 	 * \brief Append an array to the buffer by first writing the size
 	 * \param data The buffer to append
@@ -140,6 +154,23 @@ class DataBuffer {
 		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 an array from the buffer
 	 */

include/sp/common/VarInt.h

@@ -21,6 +21,8 @@ class VarInt {
 	std::uint64_t m_Value;
 
   public:
+	static const std::uint64_t MAX_VALUE = static_cast<std::uint64_t>(-1) >> 8;
+
 	VarInt() : m_Value(0) {}
 	/**
 	 * \brief Construct a variable integer from a value

include/sp/default/DefaultPacket.h

@@ -6,12 +6,13 @@
 namespace sp {
 class PacketHandler;
 
-using PacketMessage = Message<option::MsgIdType<std::uint8_t>,	// add id() operation
+using PacketMessage = Message<
-	option::ReadOperations,										// add read() operation
+	option::MsgIdType<std::uint8_t>,		// add id() operation
-	option::WriteOperations,									// add write() operation
+	option::ReadOperations,					// add read() operation
-	option::WriteId,											// write id before data
+	option::WriteOperations,				// add write() operation
-	option::Handler<PacketHandler>								// add dispatch() operation
+	option::WriteId,						// write id before data
-	>;
+	option::Handler<PacketHandler>			// add dispatch() operation
+>;
 
 #define PacketConstructor(packetName)                                                                                                 \
 	packetName##Packet() {}                                                                                                           \

include/sp/default/DefaultPacketDispatcher.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <sp/default/DefaultPacket.h>
+#include <sp/default/DefaultPacketHandler.h>
+#include <sp/protocol/MessageDispatcher.h>
+
+namespace sp {
+
+using PacketDispatcher = MessageDispatcher<
+	PacketMessage::ParsedOptions::MsgIdType, 
+	PacketMessage, 
+	PacketMessage::ParsedOptions::HandlerType::HandlerT
+	>;
+
+}  // namespace sp

include/sp/extensions/Compress.h

@@ -0,0 +1,54 @@
+#pragma once
+
+/**
+ * \file Compression.h
+ * \brief File containing compress utilities
+ */
+
+#include <cstdint>
+#include <sp/common/DataBuffer.h>
+
+namespace sp {
+namespace option {
+
+struct ZlibCompress {
+	bool m_Enabled = true;
+	std::size_t m_CompressionThreshold = 64;
+};
+
+}  // namespace option
+}  // namespace sp
+
+#include <sp/io/IOInterface.h>
+
+namespace sp {
+namespace zlib {
+
+/**
+ * \brief Compress some data
+ * \param buffer the data to compress
+ * \return the compressed data
+ */
+DataBuffer Compress(const DataBuffer& buffer, std::size_t a_CompressionThreshold = 64);
+
+/**
+ * \brief Uncompress some data
+ * \param buffer the data to uncompress
+ * \param packetLength lenght of data
+ * \return the uncompressed data
+ */
+DataBuffer Decompress(DataBuffer& buffer, std::uint64_t packetLength);
+
+}  // namespace zlib
+
+namespace io {
+
+template <>
+class MessageEncapsulator<option::ZlibCompress> {
+  public:
+	static DataBuffer Encapsulate(const DataBuffer& a_Data, const option::ZlibCompress& a_Option);
+	static DataBuffer Decapsulate(DataBuffer& a_Data, const option::ZlibCompress& a_Option);
+};
+
+}  // namespace io
+}  // namespace sp

include/sp/extensions/Encrypt.h

@@ -0,0 +1,41 @@
+#pragma once
+
+/**
+ * \file Encrypt.h
+ * \brief File containing encrypt utilities
+ */
+
+#include <sp/common/DataBuffer.h>
+
+namespace sp {
+namespace option {
+
+struct TlsEncrypt {
+	bool m_Enabled = true;
+};
+
+}  // namespace option
+}  // namespace sp
+
+#include <sp/io/IOInterface.h>
+
+namespace sp {
+namespace ssl {
+
+// encrypt
+
+// decrypt
+
+}  // namespace ssl
+
+namespace io {
+
+template <>
+class MessageEncapsulator<option::TlsEncrypt> {
+  public:
+	static DataBuffer Encapsulate(const DataBuffer& a_Data, const option::TlsEncrypt& a_Option);
+	static DataBuffer Decapsulate(DataBuffer& a_Data, const option::TlsEncrypt& a_Option);
+};
+
+}  // namespace io
+}  // namespace sp

include/sp/extensions/Extensions.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#if __has_include(<sp/extensions/Compress.h>)
+	#include <sp/extensions/Compress.h>
+#endif

include/sp/io/File.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <fstream>
+#include <sp/io/IOInterface.h>
+
+namespace sp {
+namespace io {
+
+struct FileTag {
+	enum OpenMode {
+		In = 1,
+		Out = 1 << 1,
+	};
+};
+
+template <>
+class IOInterface<FileTag> {
+  private:
+	std::unique_ptr<std::ifstream> m_FileInput;
+	std::unique_ptr<std::ofstream> m_FileOutput;
+
+  public:
+	IOInterface(const std::string& a_FilePath, unsigned int a_OpenMode);
+	IOInterface(IOInterface&& other);
+
+	DataBuffer Read(std::size_t a_Amount);
+	void Write(const sp::DataBuffer& a_Data);
+};
+
+using File = IOInterface<FileTag>;
+
+}  // namespace io
+}  // namespace sp

include/sp/io/IOInterface.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <memory>
+#include <sp/common/DataBuffer.h>
+
+namespace sp {
+namespace io {
+
+template <typename IOTag>
+class IOInterface {
+  public:
+	DataBuffer Read(std::size_t a_Amount);
+	void Write(const DataBuffer& a_Data);
+};
+
+template <typename TOption>
+class MessageEncapsulator {
+  public:
+	static DataBuffer Encapsulate(const DataBuffer& a_Data, const TOption& a_Option);
+	static DataBuffer Decapsulate(DataBuffer& a_Data, const TOption& a_Option);
+};
+
+template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
+class Stream {
+  protected:
+	MessageDispatcher m_Dispatcher;
+	IOInterface<IOTag> m_Interface;
+	std::tuple<TOptions...> m_Options;
+
+	using MessageBase = typename MessageDispatcher::MessageBaseType;
+
+  public:
+	Stream() {}
+	Stream(IOInterface<IOTag>&& a_Interface, TOptions&&... a_Options);
+	Stream(Stream&& a_Stream);
+
+	void RecieveMessages();
+	void SendMessage(const MessageBase& a_Message);
+
+
+	template <typename TOption>
+	TOption& GetOption() {
+		return std::get<TOption>(m_Options);
+	}
+
+	MessageDispatcher& GetDispatcher() {
+		return m_Dispatcher;
+	}
+
+  private:
+	static DataBuffer Encapsulate(const DataBuffer& a_Data, const TOptions&... a_Options);
+	static DataBuffer Decapsulate(DataBuffer& a_Data, const TOptions&... a_Options);
+};
+
+}  // namespace io
+}  // namespace sp
+
+#include <sp/io/IOInterfaceImpl.inl>

include/sp/io/IOInterfaceImpl.inl

@@ -0,0 +1,128 @@
+#pragma once
+
+#include <sp/extensions/Compress.h>
+#include <stdexcept>
+
+namespace sp {
+
+namespace details {
+
+template <typename... TOptions>
+struct MessageEncapsulatorPack {};
+
+template <>
+struct MessageEncapsulatorPack<> {
+	static DataBuffer Encapsulate(const DataBuffer& a_Data) {
+		return a_Data;
+	}
+	static DataBuffer Decapsulate(DataBuffer& a_Data) {
+		return a_Data;
+	}
+};
+
+template <typename TOption, typename... TOptions>
+struct MessageEncapsulatorPack<TOption, TOptions...> {
+	static DataBuffer Encapsulate(const DataBuffer& a_Data, const TOption& a_Option, const TOptions&... a_Options) {
+		DataBuffer data = io::MessageEncapsulator<TOption>::Encapsulate(a_Data, a_Option);
+		return MessageEncapsulatorPack<TOptions...>::Encapsulate(data, a_Options...);
+	}
+	static DataBuffer Decapsulate(DataBuffer& a_Data, const TOption& a_Option, const TOptions&... a_Options) {
+		DataBuffer data = io::MessageEncapsulator<TOption>::Decapsulate(a_Data, a_Option);
+		return MessageEncapsulatorPack<TOptions...>::Decapsulate(data, a_Options...);
+	}
+};
+
+}  // namespace details
+
+namespace io {
+
+template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
+Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Stream(IOInterface<IOTag>&& a_Interface, TOptions&&... a_Options) :
+	m_Interface(std::move(a_Interface)), m_Options(std::make_tuple<TOptions...>(std::move(a_Options)...)) {}
+
+template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
+Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Stream(
+	Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>&& a_Stream) :
+	m_Dispatcher(std::move(a_Stream.m_Dispatcher)), m_Interface(std::move(a_Stream.m_Interface)) {}
+
+template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
+void Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::SendMessage(const MessageBase& a_Message) {
+	DataBuffer data = a_Message.Write();
+	DataBuffer encapsulated = std::apply([&data](const auto&... a_Options) {
+		return Encapsulate(data, a_Options...);
+	}, m_Options);
+	DataBuffer finalData;
+	finalData << VarInt{encapsulated.GetSize()} << encapsulated;
+	m_Interface.Write(finalData);
+}
+
+template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
+void Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::RecieveMessages() {
+	while (true) {
+		// reading the first VarInt part byte by byte
+		std::uint64_t lenghtValue = 0;
+		unsigned int readPos = 0;
+
+		while (true) {
+			static constexpr int SEGMENT_BITS = (1 << 7) - 1;
+			static constexpr int CONTINUE_BIT = 1 << 7;
+
+			DataBuffer buffer = m_Interface.Read(sizeof(std::uint8_t));
+
+			// eof
+			if (buffer.GetSize() == 0)
+				return;
+
+			std::uint8_t part;
+			buffer >> part;
+			lenghtValue |= static_cast<std::uint64_t>(part & SEGMENT_BITS) << readPos;
+
+			if ((part & CONTINUE_BIT) == 0)
+				break;
+
+			readPos += 7;
+
+			if (readPos >= 8 * sizeof(lenghtValue))
+				throw std::runtime_error("VarInt is too big");
+		}
+
+		// nothing to read
+		if (lenghtValue == 0)
+			return;
+
+		DataBuffer buffer;
+		buffer = m_Interface.Read(lenghtValue);
+
+		buffer = std::apply([&buffer, lenghtValue](const auto&... a_Options) {
+			return Decapsulate(buffer, a_Options...);
+		}, m_Options);
+
+		VarInt packetType;
+		buffer >> packetType;
+
+		static const MessageFactory messageFactory;
+
+		std::unique_ptr<MessageBase> message = messageFactory.CreateMessage(packetType.GetValue());
+
+		assert(message != nullptr);
+
+		message->Read(buffer);
+
+		GetDispatcher().Dispatch(*message);
+	}
+}
+
+template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
+DataBuffer Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Encapsulate(
+	const DataBuffer& a_Data, const TOptions&... a_Options) {
+	return details::MessageEncapsulatorPack<TOptions...>::Encapsulate(a_Data, a_Options...);
+}
+
+template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
+DataBuffer Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Decapsulate(
+	DataBuffer& a_Data, const TOptions&... a_Options) {
+	return details::MessageEncapsulatorPack<TOptions...>::Decapsulate(a_Data, a_Options...);
+}
+
+}  // namespace io
+}  // namespace sp

include/sp/io/Memory.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <sp/io/IOInterface.h>
+
+namespace sp {
+namespace io {
+
+struct MemoryTag {};
+
+template <>
+class IOInterface<MemoryTag> {
+  private:
+	sp::DataBuffer m_VirtualIO;
+
+  public:
+	sp::DataBuffer Read(std::size_t a_Amount);
+	void Write(const sp::DataBuffer& a_Data);
+};
+
+using Memory = IOInterface<MemoryTag>;
+
+}  // namespace io
+}  // namespace sp

include/sp/protocol/Field.h

@@ -45,6 +45,12 @@ class BitField {
 		return std::get<FIndex>(this->GetFields()).GetValue();
 	}
 
+	// allow use of enums
+	template <typename E, E FIndex>
+	const auto& GetField() const {
+		return std::get<static_cast<std::size_t>(FIndex)>(this->GetFields()).GetValue();
+	}
+
   private:
 	template <int IOffset, typename... T, std::enable_if_t<IOffset >= sizeof...(T), bool> = true>
 	void Apply(const std::tuple<T...>& args) {}
@@ -108,6 +114,6 @@ template <typename TField, typename... TFields>
 struct FieldsBuilder<TField, TFields...> {
 	using Type = sp::tuple_cat_t<std::tuple<Field<TField, 0>>, typename FieldsBuilder<TFields...>::Type>;
 };
-}  // namespace details
 
+}  // namespace details
 }  // namespace sp

include/sp/protocol/MessageBase.h

@@ -2,344 +2,15 @@
 
 #include <sp/protocol/Message.h>
 
+#include <sp/protocol/message/MessageImplOptions.h>
+
+#include <sp/protocol/message/MessagesImpl.h>
+#include <sp/protocol/message/MessageImplProcess.h>
+#include <sp/protocol/message/MessageImplBuilder.h>
+
 namespace sp {
-namespace option {
-
-// Provide static numeric ID, to facilitate implementation of GetIdImpl()
-template <std::intmax_t TId>
-struct StaticNumIdImpl {};
-
-// Facilitate implementation of DispatchImpl()
-template <typename TActual>
-struct DispatchImpl {};
-
-// Provide fields of the message, facilitate implementation of
-// ReadImpl(), WriteImpl(), ValidImpl(), etc...
-template <typename TFields>
-struct FieldsImpl {};
-
-}  // namespace option
-
-
-namespace details {
-
-
-
-
-
-template <typename... TOptions>
-class MessageImplParsedOptions;
-
-template <>
-struct MessageImplParsedOptions<> {
-	static const bool HasStaticNumIdImpl = false;
-	static const bool HasDispatchImpl = false;
-	static const bool HasFieldsImpl = false;
-};
-
-
-
-
-
-template <std::intmax_t TId, typename... TOptions>
-struct MessageImplParsedOptions<option::StaticNumIdImpl<TId>, TOptions...> : public MessageImplParsedOptions<TOptions...> {
-	static const bool HasStaticNumIdImpl = true;
-	static const std::intmax_t MsgId = TId;
-};
-
-template <typename TActual, typename... TOptions>
-struct MessageImplParsedOptions<option::DispatchImpl<TActual>, TOptions...> : public MessageImplParsedOptions<TOptions...> {
-	static const bool HasDispatchImpl = true;
-	using ActualMessage = TActual;
-};
-
-template <typename TFields, typename... TOptions>
-struct MessageImplParsedOptions<option::FieldsImpl<TFields>, TOptions...> : public MessageImplParsedOptions<TOptions...> {
-	static const bool HasFieldsImpl = true;
-	using Fields = TFields;
-};
-
-
-
-
-
-// ID information chunk
-template <typename TBase, std::intmax_t TId>
-class MessageImplStaticNumIdBase : public TBase {
-  public:
-	// Reuse the message ID type defined in the interface
-	using MsgIdType = typename TBase::MsgIdType;
-
-  protected:
-	virtual MsgIdType GetIdImpl() const override {
-		return static_cast<MsgIdType>(TId);
-	}
-};
-
-// Dispatch implementation chunk
-template <typename TBase, typename TActual>
-class MessageImplDispatchBase : public TBase {
-  public:
-	// Reuse the Handler type defined in the interface class
-	using Handler = typename TBase::HandlerType;
-
-  protected:
-	virtual void DispatchImpl(Handler& handler) override {
-		handler.Handle(static_cast<TActual&>(*this));
-	}
-};
-
-
-
-template <typename TBase, typename TFields>
-class MessageImplFieldsBase : public TBase {
-  public:
-	using AllFields = typename details::FieldsBuilder<TFields>::Type;
-
-	template <typename... Args>
-	void Construct(Args... args) {
-		m_Fields = std::make_tuple(args...);
-	}
-
-	AllFields& GetFields() {
-		return m_Fields;
-	}
-
-	const AllFields& GetFields() const {
-		return m_Fields;
-	}
-
-	template <std::size_t FIndex>
-	auto& GetField() {
-		return std::get<FIndex>(GetFields()).GetValue();
-	}
-
-	template <std::size_t FIndex>
-	const auto& GetField() const {
-		return std::get<FIndex>(GetFields()).GetValue();
-	}
-
-  private:
-	AllFields m_Fields;
-};
-
-template <typename TBase>
-class MessageImplFieldsReadBase : public TBase {
-  private:
-	// normal reading
-	template <typename TField>
-	void ReadField(Field<TField, 0>& field, DataBuffer& buffer) {
-		this->ReadData(field.GetValue(), buffer);
-	}
-
-	// reading field in bitfield
-	template <typename TFieldType, typename TField, int IAlignment>
-	void ReadField(Field<TField, IAlignment>& field, TFieldType data, std::size_t offset) {
-		static constexpr std::size_t TotalBitCount = sizeof(TFieldType) * 8;
-		// we suppose that the first element is at the highest bits
-		field.GetValue() = (data >> TotalBitCount - IAlignment - offset) & ((1 << IAlignment) - 1);
-	}
-
-	// reading bitfield
-	template <typename TContainer, typename TFirst, typename... TFields>
-	void ReadField(Field<BitField<TContainer, TFirst, TFields...>, 0>& field, DataBuffer& buffer) {
-		TContainer data;
-		this->ReadData(data, buffer);
-		std::size_t offset = 0;
-		TupleForEach(
-			[data, this, &offset](auto& field) {
-				this->ReadField(field, data, offset);
-				offset += field.GetAlignment();
-			},
-			field.GetValue().GetFields());
-	}
-
-	void ReadImpl(DataBuffer& buffer) override {
-		auto& allFields = this->GetFields();
-		TupleForEach([&buffer, this](auto& field) { this->ReadField(field, buffer); }, allFields);
-	}
-};
-
-template <typename TBase>
-class MessageImplFieldsWriteBase : public TBase {
-  private:
-	// normal writing
-	template <typename TField>
-	void WriteField(Field<TField, 0>& field, DataBuffer& buffer) {
-		this->WriteData(field.GetValue(), buffer);
-	}
-
-	// writing field in bitfield
-	template <typename TFieldType, typename TField, int IAlignment>
-	void WriteField(Field<TField, IAlignment>& field, TFieldType& data, std::size_t offset) {
-		static constexpr std::size_t TotalBitCount = sizeof(TFieldType) * 8;
-		// we suppose that the first element is at the highest bits
-		data |= (field.GetValue() & ((1 << IAlignment) - 1)) << TotalBitCount - IAlignment - offset;
-	}
-
-	// writing bitfield
-	template <typename TContainer, typename TFirst, typename... TFields>
-	void WriteField(Field<BitField<TContainer, TFirst, TFields...>, 0>& field, DataBuffer& buffer) {
-		TContainer data = 0;
-		std::size_t offset = 0;
-		TupleForEach(
-			[&data, this, &offset](auto& field) {
-				this->WriteField(field, data, offset);
-				offset += field.GetAlignment();
-			},
-			field.GetValue().GetFields());
-		this->WriteData(data, buffer);
-	}
-
-	void WriteImpl(DataBuffer& buffer) override {
-		auto& allFields = this->GetFields();
-		TupleForEach([&buffer, this](auto& field) { this->WriteField(field, buffer); }, allFields);
-	}
-};
-
-template <typename TBase>
-class MessageImplFieldsValidBase : public TBase {
-  protected:
-	bool ValidImpl() const override {
-		// Access fields via interface provided in previous chunk
-		// auto& allFields = TBase::GetFields();
-		//...	 // validate all the fields
-		return true;
-	}
-};
-
-
-
-
-// id impl
-template <typename TBase, typename ParsedImplOptions, bool TImplement>
-struct MessageImplProcessStaticNumId;
-
-template <typename TBase, typename ParsedImplOptions>
-struct MessageImplProcessStaticNumId<TBase, ParsedImplOptions, true> {
-	using Type = MessageImplStaticNumIdBase<TBase, ParsedImplOptions::MsgId>;
-};
-
-template <typename TBase, typename ParsedImplOptions>
-struct MessageImplProcessStaticNumId<TBase, ParsedImplOptions, false> {
-	using Type = TBase;
-};
-
-// dispatch impl
-template <typename TBase, typename ParsedImplOptions, bool TImplement>
-struct MessageImplProcessDispatch;
-
-template <typename TBase, typename ParsedImplOptions>
-struct MessageImplProcessDispatch<TBase, ParsedImplOptions, true> {
-	using Type = MessageImplDispatchBase<TBase, typename ParsedImplOptions::ActualMessage>;
-};
-
-template <typename TBase, typename ParsedImplOptions>
-struct MessageImplProcessDispatch<TBase, ParsedImplOptions, false> {
-	using Type = TBase;
-};
-
-// fields impl
-template <typename TBase, typename ParsedImplOptions, bool TImplement>
-struct MessageImplProcessFields;
-
-template <typename TBase, typename ParsedImplOptions>
-struct MessageImplProcessFields<TBase, ParsedImplOptions, true> {
-	using Type = MessageImplFieldsBase<TBase, typename ParsedImplOptions::Fields>;
-};
-
-template <typename TBase, typename ParsedImplOptions>
-struct MessageImplProcessFields<TBase, ParsedImplOptions, false> {
-	using Type = TBase;
-};
-
-// read impl
-template <typename TBase, bool TImplement>
-struct MessageImplProcessReadFields;
-
-template <typename TBase>
-struct MessageImplProcessReadFields<TBase, true> {
-	using Type = MessageImplFieldsReadBase<TBase>;
-};
-
-template <typename TBase>
-struct MessageImplProcessReadFields<TBase, false> {
-	using Type = TBase;
-};
-
-// write impl
-template <typename TBase, bool TImplement>
-struct MessageImplProcessWriteFields;
-
-template <typename TBase>
-struct MessageImplProcessWriteFields<TBase, true> {
-	using Type = MessageImplFieldsWriteBase<TBase>;
-};
-
-template <typename TBase>
-struct MessageImplProcessWriteFields<TBase, false> {
-	using Type = TBase;
-};
-
-// valid impl
-template <typename TBase, bool TImplement>
-struct MessageImplProcessValidFields;
-
-template <typename TBase>
-struct MessageImplProcessValidFields<TBase, true> {
-	using Type = MessageImplFieldsValidBase<TBase>;
-};
-
-template <typename TBase>
-struct MessageImplProcessValidFields<TBase, false> {
-	using Type = TBase;
-};
-
-
-
-
-
-// TBase is interface class
-// TOptions... are the implementation options
-template <typename TBase, typename... TOptions>
-struct MessageImplBuilder {
-	// ParsedOptions class is supposed to be defined in comms::Message class
-	using InterfaceOptions = typename TBase::ParsedOptions;
-
-	// Parse implementation options
-	using ImplOptions = MessageImplParsedOptions<TOptions...>;
-
-	// Provide GetIdImpl() if possible
-	static const bool HasStaticNumIdImpl = InterfaceOptions::HasMsgIdType && ImplOptions::HasStaticNumIdImpl;
-	using Base1 = typename MessageImplProcessStaticNumId<TBase, ImplOptions, HasStaticNumIdImpl>::Type;
-
-	// Provide DispatchImpl() if possible
-	static const bool HasDispatchImpl = InterfaceOptions::HasHandler && ImplOptions::HasDispatchImpl;
-	using Base2 = typename MessageImplProcessDispatch<Base1, ImplOptions, HasDispatchImpl>::Type;
-
-	// Provide access to fields if possible
-	using Base3 = typename MessageImplProcessFields<Base2, ImplOptions, ImplOptions::HasFieldsImpl>::Type;
-
-	// Provide ReadImpl() if possible
-	static const bool HasReadImpl = InterfaceOptions::HasReadOperations && ImplOptions::HasFieldsImpl;
-	using Base4 = typename MessageImplProcessReadFields<Base3, HasReadImpl>::Type;
-
-	// Provide WriteImpl() if possible
-	static const bool HasWriteImpl = InterfaceOptions::HasWriteOperations && ImplOptions::HasFieldsImpl;
-	using Base5 = typename MessageImplProcessWriteFields<Base4, HasWriteImpl>::Type;
-
-	// Provide ValidImpl() if possible
-	static const bool HasValidImpl = InterfaceOptions::HasValid && ImplOptions::HasFieldsImpl;
-	using Base6 = typename MessageImplProcessValidFields<Base5, HasValidImpl>::Type;
-
-	// The last BaseN must be taken as final type.
-	using Type = Base6;
-};
-
-}  // namespace details
 
 template <typename TBase, typename... TOptions>
 class MessageBase : public details::MessageImplBuilder<TBase, TOptions...>::Type {};
 
-
 }  // namespace sp

include/sp/protocol/MessageDispatcher.h

@@ -0,0 +1,57 @@
+#pragma once
+
+/**
+ * \file MessageDispatcher.h
+ * \brief File containing the sp::MessageDispatcher class
+ */
+
+#include <map>
+#include <memory>
+
+namespace sp {
+
+/**
+ * \class MessageDispatcher
+ * \brief Class used to dispatch messages
+ */
+template <typename MessageIdType, typename MessageBase, typename MessageHandler>
+class MessageDispatcher {
+  private:
+	std::map<MessageIdType, std::vector<std::shared_ptr<MessageHandler>>> m_Handlers;
+
+  public:
+	using MessageBaseType = MessageBase;
+
+	/**
+	 * \brief Constructor
+	 */
+	MessageDispatcher() {}
+
+	/**
+	 * \brief Dispatch a packet
+	 * \param packet The packet to dispatch
+	 */
+	void Dispatch(const MessageBase& a_Message);
+
+	/**
+	 * \brief Register a packet handler
+	 * \param type The packet type
+	 * \param handler The packet handler
+	 */
+	void RegisterHandler(MessageIdType a_MessageType, const std::shared_ptr<MessageHandler>& a_Handler);
+	/**
+	 * \brief Unregister a packet handler
+	 * \param type The packet type
+	 * \param handler The packet handler
+	 */
+	void UnregisterHandler(MessageIdType a_MessageType, const std::shared_ptr<MessageHandler>& a_Handler);
+	/**
+	 * \brief Unregister a packet handler
+	 * \param handler The packet handler
+	 */
+	void UnregisterHandler(const std::shared_ptr<MessageHandler>& a_Handler);
+};
+
+#include <sp/protocol/message/MessageDispatcherImpl.inl>
+
+}  // namespace sp

include/sp/protocol/MessageFactory.h

@@ -5,45 +5,10 @@
 #include <iostream>
 #include <memory>
 
+#include <sp/protocol/message/ArrayFillerImpl.h>
+
 namespace sp {
 
-namespace details {
-
-template <typename TBase>
-using ArrayType = std::vector<std::function<std::unique_ptr<TBase>(void)>>;
-
-
-
-template <typename TBase, typename... TMessages>
-struct ArrayFiller {};
-
-template <typename TBase, typename... TMessages>
-struct ArrayFiller<TBase, std::tuple<TMessages...>> {
-	static ArrayType<TBase> ArrayCreate() {
-		ArrayType<TBase> array;
-		array.reserve(sizeof...(TMessages));
-		ArrayFiller<TBase, TMessages...>::ArrayAppend(array);
-		return array;
-	}
-};
-
-template <typename TBase, typename TMessage, typename... TMessages>
-struct ArrayFiller<TBase, TMessage, TMessages...> {
-	static void ArrayAppend(details::ArrayType<TBase>& array) {
-		ArrayFiller<TBase, TMessage>::ArrayAppend(array);
-		ArrayFiller<TBase, TMessages...>::ArrayAppend(array);
-	}
-};
-
-template <typename TBase, typename TMessage>
-struct ArrayFiller<TBase, TMessage> {
-	static void ArrayAppend(details::ArrayType<TBase>& array) {
-		array.push_back([]() -> std::unique_ptr<TBase> { return std::make_unique<TMessage>(); });
-	}
-};
-
-}  // namespace details
-
 template <typename TBase, typename TTMessages>
 class MessageFactory {
   public:
@@ -51,7 +16,7 @@ class MessageFactory {
 
 	MessageFactory() : m_Factory(details::ArrayFiller<TBase, TTMessages>::ArrayCreate()) {}
 
-	std::unique_ptr<TBase> CreateMessage(IdType id) {
+	std::unique_ptr<TBase> CreateMessage(IdType id) const {
 		if (id >= m_Factory.size())
 			return nullptr;
 		return m_Factory.at(id)();

include/sp/protocol/message/ArrayFillerImpl.h

@@ -0,0 +1,39 @@
+#pragma once
+
+namespace sp {
+namespace details {
+
+template <typename TBase>
+using ArrayType = std::vector<std::function<std::unique_ptr<TBase>(void)>>;
+
+
+template <typename TBase, typename... TMessages>
+struct ArrayFiller {};
+
+template <typename TBase, typename... TMessages>
+struct ArrayFiller<TBase, std::tuple<TMessages...>> {
+	static ArrayType<TBase> ArrayCreate() {
+		ArrayType<TBase> array;
+		array.reserve(sizeof...(TMessages));
+		ArrayFiller<TBase, TMessages...>::ArrayAppend(array);
+		return array;
+	}
+};
+
+template <typename TBase, typename TMessage, typename... TMessages>
+struct ArrayFiller<TBase, TMessage, TMessages...> {
+	static void ArrayAppend(details::ArrayType<TBase>& array) {
+		ArrayFiller<TBase, TMessage>::ArrayAppend(array);
+		ArrayFiller<TBase, TMessages...>::ArrayAppend(array);
+	}
+};
+
+template <typename TBase, typename TMessage>
+struct ArrayFiller<TBase, TMessage> {
+	static void ArrayAppend(details::ArrayType<TBase>& array) {
+		array.push_back([]() -> std::unique_ptr<TBase> { return std::make_unique<TMessage>(); });
+	}
+};
+
+}  // namespace details
+}  // namespace sp

include/sp/protocol/message/MessageDispatcherImpl.inl

@@ -0,0 +1,34 @@
+#pragma once
+
+template <typename MessageIdType, typename MessageBase, typename MessageHandler>
+void MessageDispatcher<MessageIdType, MessageBase, MessageHandler>::RegisterHandler(MessageIdType a_MessageType, const std::shared_ptr<MessageHandler>& a_Handler) {
+	auto found = std::find(m_Handlers[a_MessageType].begin(), m_Handlers[a_MessageType].end(), a_Handler);
+	if (found == m_Handlers[a_MessageType].end())
+		m_Handlers[a_MessageType].push_back(a_Handler);
+}
+
+template <typename MessageIdType, typename MessageBase, typename MessageHandler>
+void MessageDispatcher<MessageIdType, MessageBase, MessageHandler>::UnregisterHandler(MessageIdType a_MessageType, const std::shared_ptr<MessageHandler>& a_Handler) {
+	auto found = std::find(m_Handlers[a_MessageType].begin(), m_Handlers[a_MessageType].end(), a_Handler);
+	if (found != m_Handlers[a_MessageType].end())
+		m_Handlers[a_MessageType].erase(found);
+}
+
+template <typename MessageIdType, typename MessageBase, typename MessageHandler>
+void MessageDispatcher<MessageIdType, MessageBase, MessageHandler>::UnregisterHandler(const std::shared_ptr<MessageHandler>& a_Handler) {
+	for (auto& pair : m_Handlers) {
+		if (pair.second.empty())
+			continue;
+
+		MessageIdType type = pair.first;
+
+		m_Handlers[type].erase(std::remove(m_Handlers[type].begin(), m_Handlers[type].end(), a_Handler), m_Handlers[type].end());
+	}
+}
+
+template <typename MessageIdType, typename MessageBase, typename MessageHandler>
+void MessageDispatcher<MessageIdType, MessageBase, MessageHandler>::Dispatch(const MessageBase& a_Message) {
+	MessageIdType type = a_Message.GetId();
+	for (auto& handler : m_Handlers[type])
+		a_Message.Dispatch(*handler);
+}

include/sp/protocol/message/MessageImplBuilder.h

@@ -0,0 +1,45 @@
+#pragma once
+
+namespace sp {
+namespace details {
+
+
+// TBase is interface class
+// TOptions... are the implementation options
+template <typename TBase, typename... TOptions>
+struct MessageImplBuilder {
+	// ParsedOptions class is supposed to be defined in comms::Message class
+	using InterfaceOptions = typename TBase::ParsedOptions;
+
+	// Parse implementation options
+	using ImplOptions = MessageImplParsedOptions<TOptions...>;
+
+	// Provide GetIdImpl() if possible
+	static const bool HasStaticNumIdImpl = InterfaceOptions::HasMsgIdType && ImplOptions::HasStaticNumIdImpl;
+	using Base1 = typename MessageImplProcessStaticNumId<TBase, ImplOptions, HasStaticNumIdImpl>::Type;
+
+	// Provide DispatchImpl() if possible
+	static const bool HasDispatchImpl = InterfaceOptions::HasHandler && ImplOptions::HasDispatchImpl;
+	using Base2 = typename MessageImplProcessDispatch<Base1, ImplOptions, HasDispatchImpl>::Type;
+
+	// Provide access to fields if possible
+	using Base3 = typename MessageImplProcessFields<Base2, ImplOptions, ImplOptions::HasFieldsImpl>::Type;
+
+	// Provide ReadImpl() if possible
+	static const bool HasReadImpl = InterfaceOptions::HasReadOperations && ImplOptions::HasFieldsImpl;
+	using Base4 = typename MessageImplProcessReadFields<Base3, HasReadImpl>::Type;
+
+	// Provide WriteImpl() if possible
+	static const bool HasWriteImpl = InterfaceOptions::HasWriteOperations && ImplOptions::HasFieldsImpl;
+	using Base5 = typename MessageImplProcessWriteFields<Base4, HasWriteImpl>::Type;
+
+	// Provide ValidImpl() if possible
+	static const bool HasValidImpl = InterfaceOptions::HasValid && ImplOptions::HasFieldsImpl;
+	using Base6 = typename MessageImplProcessValidFields<Base5, HasValidImpl>::Type;
+
+	// The last BaseN must be taken as final type.
+	using Type = Base6;
+};
+
+}  // namespace details
+}  // namespace sp

include/sp/protocol/message/MessageImplOptions.h

@@ -0,0 +1,61 @@
+#pragma once
+
+namespace sp {
+namespace option {
+
+// Provide static numeric ID, to facilitate implementation of GetIdImpl()
+template <std::intmax_t TId>
+struct StaticNumIdImpl {};
+
+// Facilitate implementation of DispatchImpl()
+template <typename TActual>
+struct DispatchImpl {};
+
+// Provide fields of the message, facilitate implementation of
+// ReadImpl(), WriteImpl(), ValidImpl(), etc...
+template <typename TFields>
+struct FieldsImpl {};
+
+}  // namespace option
+
+
+namespace details {
+
+
+
+
+
+template <typename... TOptions>
+class MessageImplParsedOptions;
+
+template <>
+struct MessageImplParsedOptions<> {
+	static const bool HasStaticNumIdImpl = false;
+	static const bool HasDispatchImpl = false;
+	static const bool HasFieldsImpl = false;
+};
+
+
+
+
+
+template <std::intmax_t TId, typename... TOptions>
+struct MessageImplParsedOptions<option::StaticNumIdImpl<TId>, TOptions...> : public MessageImplParsedOptions<TOptions...> {
+	static const bool HasStaticNumIdImpl = true;
+	static const std::intmax_t MsgId = TId;
+};
+
+template <typename TActual, typename... TOptions>
+struct MessageImplParsedOptions<option::DispatchImpl<TActual>, TOptions...> : public MessageImplParsedOptions<TOptions...> {
+	static const bool HasDispatchImpl = true;
+	using ActualMessage = TActual;
+};
+
+template <typename TFields, typename... TOptions>
+struct MessageImplParsedOptions<option::FieldsImpl<TFields>, TOptions...> : public MessageImplParsedOptions<TOptions...> {
+	static const bool HasFieldsImpl = true;
+	using Fields = TFields;
+};
+
+}  // namespace details
+}  // namespace sp

include/sp/protocol/message/MessageImplProcess.h

@@ -0,0 +1,93 @@
+#pragma once
+
+namespace sp {
+namespace details {
+
+
+
+// id impl
+template <typename TBase, typename ParsedImplOptions, bool TImplement>
+struct MessageImplProcessStaticNumId;
+
+template <typename TBase, typename ParsedImplOptions>
+struct MessageImplProcessStaticNumId<TBase, ParsedImplOptions, true> {
+	using Type = MessageImplStaticNumIdBase<TBase, ParsedImplOptions::MsgId>;
+};
+
+template <typename TBase, typename ParsedImplOptions>
+struct MessageImplProcessStaticNumId<TBase, ParsedImplOptions, false> {
+	using Type = TBase;
+};
+
+// dispatch impl
+template <typename TBase, typename ParsedImplOptions, bool TImplement>
+struct MessageImplProcessDispatch;
+
+template <typename TBase, typename ParsedImplOptions>
+struct MessageImplProcessDispatch<TBase, ParsedImplOptions, true> {
+	using Type = MessageImplDispatchBase<TBase, typename ParsedImplOptions::ActualMessage>;
+};
+
+template <typename TBase, typename ParsedImplOptions>
+struct MessageImplProcessDispatch<TBase, ParsedImplOptions, false> {
+	using Type = TBase;
+};
+
+// fields impl
+template <typename TBase, typename ParsedImplOptions, bool TImplement>
+struct MessageImplProcessFields;
+
+template <typename TBase, typename ParsedImplOptions>
+struct MessageImplProcessFields<TBase, ParsedImplOptions, true> {
+	using Type = MessageImplFieldsBase<TBase, typename ParsedImplOptions::Fields>;
+};
+
+template <typename TBase, typename ParsedImplOptions>
+struct MessageImplProcessFields<TBase, ParsedImplOptions, false> {
+	using Type = TBase;
+};
+
+// read impl
+template <typename TBase, bool TImplement>
+struct MessageImplProcessReadFields;
+
+template <typename TBase>
+struct MessageImplProcessReadFields<TBase, true> {
+	using Type = MessageImplFieldsReadBase<TBase>;
+};
+
+template <typename TBase>
+struct MessageImplProcessReadFields<TBase, false> {
+	using Type = TBase;
+};
+
+// write impl
+template <typename TBase, bool TImplement>
+struct MessageImplProcessWriteFields;
+
+template <typename TBase>
+struct MessageImplProcessWriteFields<TBase, true> {
+	using Type = MessageImplFieldsWriteBase<TBase>;
+};
+
+template <typename TBase>
+struct MessageImplProcessWriteFields<TBase, false> {
+	using Type = TBase;
+};
+
+// valid impl
+template <typename TBase, bool TImplement>
+struct MessageImplProcessValidFields;
+
+template <typename TBase>
+struct MessageImplProcessValidFields<TBase, true> {
+	using Type = MessageImplFieldsValidBase<TBase>;
+};
+
+template <typename TBase>
+struct MessageImplProcessValidFields<TBase, false> {
+	using Type = TBase;
+};
+
+}  // namespace details
+}  // namespace sp

include/sp/protocol/message/MessageInterfacesImpl.h

@@ -30,7 +30,7 @@ class MessageInterfaceBigEndian : public TBase {
 	}
 
 	template <typename T>
-	void WriteData(T value, DataBuffer& buffer) {
+	void WriteData(T value, DataBuffer& buffer) const {
 		ToNetwork(value);
 		buffer << value;
 	}
@@ -71,12 +71,19 @@ class MessageInterfaceReadBase : public TBase {
 template <typename TBase>
 class MessageInterfaceWriteBase : public TBase {
   public:
-	void Write(DataBuffer& buffer) {
+	void Write(DataBuffer& buffer) const {
 		WriteImpl(buffer);
 	}
 
+	// helper
+	DataBuffer Write() const {
+		DataBuffer buffer;
+		this->Write(buffer);
+		return buffer;
+	}
+
   protected:
-	virtual void WriteImpl(DataBuffer& buffer) = 0;
+	virtual void WriteImpl(DataBuffer& buffer) const = 0;
 };
 
 // Handler functionality chunk
@@ -85,12 +92,12 @@ class MessageInterfaceHandlerBase : public TBase {
   public:
 	using HandlerType = typename THandler::HandlerT;
 
-	void Dispatch(HandlerType& handler) {
+	void Dispatch(HandlerType& handler) const {
 		DispatchImpl(handler);
 	}
 
   protected:
-	virtual void DispatchImpl(HandlerType& handler) = 0;
+	virtual void DispatchImpl(HandlerType& handler) const = 0;
 };
 
 // Validity functionality chunk
@@ -109,10 +116,17 @@ class MessageInterfaceValidityBase : public TBase {
 template <typename TBase>
 class MessageInterfaceWriteIdBase : public TBase {
   public:
-	void Write(DataBuffer& buffer) {
+	void Write(DataBuffer& buffer) const {
-		this->WriteData(this->GetId(), buffer);
+		buffer << VarInt{this->GetId()};
 		this->WriteImpl(buffer);
 	}
+
+	// helper
+	DataBuffer Write() const {
+		DataBuffer buffer;
+		this->Write(buffer);
+		return buffer;
+	}
 };
 
 }  // namespace details

include/sp/protocol/message/MessagesImpl.h

@@ -0,0 +1,160 @@
+#pragma once
+
+namespace sp {
+namespace details {
+
+
+
+// ID information chunk
+template <typename TBase, std::intmax_t TId>
+class MessageImplStaticNumIdBase : public TBase {
+  public:
+	// Reuse the message ID type defined in the interface
+	using MsgIdType = typename TBase::MsgIdType;
+
+  protected:
+	virtual MsgIdType GetIdImpl() const override {
+		return static_cast<MsgIdType>(TId);
+	}
+};
+
+// Dispatch implementation chunk
+template <typename TBase, typename TActual>
+class MessageImplDispatchBase : public TBase {
+  public:
+	// Reuse the Handler type defined in the interface class
+	using Handler = typename TBase::HandlerType;
+
+  protected:
+	virtual void DispatchImpl(Handler& handler) const override {
+		handler.Handle(static_cast<const TActual&>(*this));
+	}
+};
+
+
+
+template <typename TBase, typename TFields>
+class MessageImplFieldsBase : public TBase {
+  public:
+	using AllFields = typename details::FieldsBuilder<TFields>::Type;
+
+	template <typename... Args>
+	void Construct(Args... args) {
+		m_Fields = std::make_tuple(args...);
+	}
+
+	AllFields& GetFields() {
+		return m_Fields;
+	}
+
+	const AllFields& GetFields() const {
+		return m_Fields;
+	}
+
+	template <std::size_t FIndex>
+	auto& GetField() {
+		return std::get<FIndex>(GetFields()).GetValue();
+	}
+
+	template <std::size_t FIndex>
+	const auto& GetField() const {
+		return std::get<FIndex>(GetFields()).GetValue();
+	}
+
+	// allow use of enums
+	template <typename E, E FIndex>
+	const auto& GetField() const {
+		return std::get<static_cast<std::size_t>(FIndex)>(this->GetFields()).GetValue();
+	}
+
+  private:
+	AllFields m_Fields;
+};
+
+template <typename TBase>
+class MessageImplFieldsReadBase : public TBase {
+  private:
+	// normal reading
+	template <typename TField>
+	void ReadField(Field<TField, 0>& field, DataBuffer& buffer) {
+		this->ReadData(field.GetValue(), buffer);
+	}
+
+	// reading field in bitfield
+	template <typename TFieldType, typename TField, int IAlignment>
+	void ReadField(Field<TField, IAlignment>& field, TFieldType data, std::size_t offset) {
+		static constexpr std::size_t TotalBitCount = sizeof(TFieldType) * 8;
+		// we suppose that the first element is at the highest bits
+		field.GetValue() = (data >> TotalBitCount - IAlignment - offset) & ((1 << IAlignment) - 1);
+	}
+
+	// reading bitfield
+	template <typename TContainer, typename TFirst, typename... TFields>
+	void ReadField(Field<BitField<TContainer, TFirst, TFields...>, 0>& field, DataBuffer& buffer) {
+		TContainer data;
+		this->ReadData(data, buffer);
+		std::size_t offset = 0;
+		TupleForEach(
+			[data, this, &offset](auto& field) {
+				this->ReadField(field, data, offset);
+				offset += field.GetAlignment();
+			},
+			field.GetValue().GetFields());
+	}
+
+	void ReadImpl(DataBuffer& buffer) override {
+		auto& allFields = this->GetFields();
+		TupleForEach([&buffer, this](auto& field) { this->ReadField(field, buffer); }, allFields);
+	}
+};
+
+template <typename TBase>
+class MessageImplFieldsWriteBase : public TBase {
+  private:
+	// normal writing
+	template <typename TField>
+	void WriteField(const Field<TField, 0>& field, DataBuffer& buffer) const {
+		this->WriteData(field.GetValue(), buffer);
+	}
+
+	// writing field in bitfield
+	template <typename TFieldType, typename TField, int IAlignment>
+	void WriteField(const Field<TField, IAlignment>& field, TFieldType& data, std::size_t offset) const {
+		static constexpr std::size_t TotalBitCount = sizeof(TFieldType) * 8;
+		// we suppose that the first element is at the highest bits
+		data |= (field.GetValue() & ((1 << IAlignment) - 1)) << TotalBitCount - IAlignment - offset;
+	}
+
+	// writing bitfield
+	template <typename TContainer, typename TFirst, typename... TFields>
+	void WriteField(const Field<BitField<TContainer, TFirst, TFields...>, 0>& field, DataBuffer& buffer) const {
+		TContainer data = 0;
+		std::size_t offset = 0;
+		TupleForEach(
+			[&data, this, &offset](auto& field) {
+				this->WriteField(field, data, offset);
+				offset += field.GetAlignment();
+			},
+			field.GetValue().GetFields());
+		this->WriteData(data, buffer);
+	}
+
+	void WriteImpl(DataBuffer& buffer) const override {
+		auto& allFields = this->GetFields();
+		TupleForEach([&buffer, this](const auto& field) { this->WriteField(field, buffer); }, allFields);
+	}
+};
+
+template <typename TBase>
+class MessageImplFieldsValidBase : public TBase {
+  protected:
+	bool ValidImpl() const override {
+		// Access fields via interface provided in previous chunk
+		// auto& allFields = TBase::GetFields();
+		//...	 // validate all the fields
+		return true;
+	}
+};
+
+}  // namespace details
+}  // namespace sp

src/sp/common/ByteSwapping.cpp

@@ -0,0 +1,74 @@
+#include <sp/common/ByteSwapping.h>
+
+#ifdef _WIN32
+#include <winsock2.h>
+#else
+#include <arpa/inet.h>
+#endif
+
+#include <algorithm>
+
+namespace sp {
+
+template <typename T>
+void SwapBytes(T& value) {
+	char* ptr = reinterpret_cast<char*>(&value);
+	std::reverse(ptr, ptr + sizeof(T));
+}
+
+bool IsSystemBigEndian() {
+	static constexpr std::uint16_t test = 10;
+	static const bool isBigEndian = reinterpret_cast<const std::uint8_t*>(&test)[1] == 10;
+	return isBigEndian;
+}
+
+template <>
+void ToNetwork<std::uint16_t>(std::uint16_t& value) {
+	value = htons(value);
+}
+
+template <>
+void ToNetwork<std::uint32_t>(std::uint32_t& value) {
+	value = htonl(value);
+}
+
+template <>
+void ToNetwork<std::uint64_t>(std::uint64_t& value) {
+	if (IsSystemBigEndian())
+		return;
+	SwapBytes(value);
+}
+
+template <>
+void FromNetwork<std::uint16_t>(std::uint16_t& value) {
+	value = ntohs(value);
+}
+
+template <>
+void FromNetwork<std::uint32_t>(std::uint32_t& value) {
+	value = ntohl(value);
+}
+
+template <>
+void FromNetwork<std::uint64_t>(std::uint64_t& value) {
+	if (IsSystemBigEndian())
+		return;
+	SwapBytes(value);
+}
+
+template <>
+void TrySwapBytes<std::uint16_t>(std::uint16_t& value) {
+	SwapBytes(value);
+}
+
+template <>
+void TrySwapBytes<std::uint32_t>(std::uint32_t& value) {
+	SwapBytes(value);
+}
+
+template <>
+void TrySwapBytes<std::uint64_t>(std::uint64_t& value) {
+	SwapBytes(value);
+}
+
+}  // namespace sp

src/sp/extensions/Compress.cpp

@@ -0,0 +1,89 @@
+#include <sp/extensions/Compress.h>
+
+#include <cassert>
+#include <sp/common/VarInt.h>
+#include <zlib.h>
+
+namespace sp {
+namespace zlib {
+
+static DataBuffer Inflate(const std::uint8_t* source, std::size_t size, std::size_t uncompressedSize) {
+	DataBuffer result;
+	result.Resize(uncompressedSize);
+
+	uncompress(static_cast<Bytef*>(result.data()), static_cast<uLongf*>(&uncompressedSize), static_cast<const Bytef*>(source),
+		static_cast<uLong>(size));
+
+	assert(result.GetSize() == uncompressedSize);
+	return result;
+}
+
+static DataBuffer Deflate(const std::uint8_t* source, std::size_t size) {
+	DataBuffer result;
+	uLongf compressedSize = size;
+
+	result.Resize(size);  // Resize for the compressed data to fit into
+	compress(static_cast<Bytef*>(result.data()), &compressedSize, static_cast<const Bytef*>(source), static_cast<uLong>(size));
+	result.Resize(compressedSize);	// Resize to cut useless data
+
+	return result;
+}
+
+DataBuffer Compress(const DataBuffer& buffer, std::size_t a_CompressionThreshold) {
+	DataBuffer packet;
+
+	if (buffer.GetSize() < a_CompressionThreshold) {
+		// Don't compress since it's a small packet
+		packet << VarInt{0};
+		packet << buffer;
+		return packet;
+	}
+
+	DataBuffer compressedData = Deflate(buffer.data(), buffer.GetSize());
+	VarInt uncompressedDataLength = buffer.GetSize();
+
+	if (compressedData.GetSize() >= buffer.GetSize()) {
+		// the compression is overkill so we don't send the compressed buffer
+		packet << VarInt{0};
+		packet << buffer;
+	} else {
+		packet << uncompressedDataLength;
+		packet << compressedData;
+	}
+
+	return packet;
+}
+
+DataBuffer Decompress(DataBuffer& buffer, std::uint64_t packetLength) {
+	VarInt uncompressedLength;
+	buffer >> uncompressedLength;
+
+	std::uint64_t compressedLength = packetLength - uncompressedLength.GetSerializedLength();
+
+	if (uncompressedLength.GetValue() == 0) {
+		// Data already uncompressed. Nothing to do
+		DataBuffer ret;
+		buffer.ReadSome(ret, compressedLength);
+		return ret;
+	}
+
+	assert(buffer.GetReadOffset() + compressedLength <= buffer.GetSize());
+
+	return Inflate(buffer.data() + buffer.GetReadOffset(), compressedLength, uncompressedLength.GetValue());
+}
+
+}  // namespace zlib
+
+namespace io {
+
+DataBuffer MessageEncapsulator<option::ZlibCompress>::Encapsulate(const DataBuffer& a_Data, const option::ZlibCompress& a_Option) {
+	static constexpr std::size_t MAX_COMPRESS_THRESHOLD = VarInt::MAX_VALUE;
+	return zlib::Compress(a_Data, a_Option.m_Enabled ? a_Option.m_CompressionThreshold : MAX_COMPRESS_THRESHOLD);
+}
+
+DataBuffer MessageEncapsulator<option::ZlibCompress>::Decapsulate(DataBuffer& a_Data, const option::ZlibCompress& a_Option) {
+	return zlib::Decompress(a_Data, a_Data.GetSize());
+}
+
+}  // namespace io
+}  // namespace sp

src/sp/extensions/Encrypt.cpp

@@ -0,0 +1,3 @@
+#include <sp/extensions/Encrypt.h>
+
+#include <openssl/ssl.h>

src/sp/io/File.cpp

@@ -0,0 +1,31 @@
+#include <sp/io/File.h>
+
+namespace sp {
+namespace io {
+
+File::IOInterface(const std::string& a_FilePath, unsigned int a_OpenMode) {
+	if (a_OpenMode & FileTag::OpenMode::In)
+		m_FileInput = std::make_unique<std::ifstream>(a_FilePath, std::ios::binary);
+	if (a_OpenMode & FileTag::OpenMode::Out)
+		m_FileOutput = std::make_unique<std::ofstream>(a_FilePath, std::ios::binary);
+}
+
+File::IOInterface(File&& other) :
+	m_FileOutput(std::move(other.m_FileOutput)), m_FileInput(std::move(other.m_FileInput)) {}
+
+DataBuffer File::Read(std::size_t a_Amount) {
+	DataBuffer buffer;
+	buffer.Resize(a_Amount);
+	assert(m_FileInput != nullptr);
+	m_FileInput->read(reinterpret_cast<char*>(buffer.data()), a_Amount);
+	return buffer;
+}
+
+void File::Write(const sp::DataBuffer& a_Data) {
+	assert(m_FileOutput != nullptr);
+	m_FileOutput->write(reinterpret_cast<const char*>(a_Data.data()), a_Data.GetSize());
+	m_FileOutput->flush();
+}
+
+}  // namespace io
+}  // namespace sp

src/sp/io/Memory.cpp

@@ -0,0 +1,16 @@
+#include <sp/io/Memory.h>
+
+namespace sp {
+namespace io {
+
+sp::DataBuffer Memory::Read(std::size_t a_Amount) {
+	DataBuffer data;
+	m_VirtualIO.ReadSome(data, a_Amount > m_VirtualIO.GetRemaining() ? m_VirtualIO.GetRemaining() : a_Amount);
+	return data;
+}
+void Memory::Write(const sp::DataBuffer& a_Data) {
+	m_VirtualIO << a_Data;
+}
+
+}  // namespace io
+}  // namespace sp

test/test_file.cpp

@@ -0,0 +1,42 @@
+#include <iostream>
+
+#include <examples/PacketExample.h>
+#include <sp/io/File.h>
+
+class CustomPacketHandler : public sp::PacketHandler {
+	void Handle(const KeepAlivePacket& packet) {
+		std::cout << "KeepAlive handled ! " << packet.GetKeepAliveId() << "\n";
+	}
+
+	void Handle(const DisconnectPacket& packet) {
+		std::cout << "Disconnect handled ! " << packet.GetReason() << "\n";
+	}
+
+	void Handle(const UpgradeTowerPacket& packet) {
+		std::cout << "UpgradeTower handled !\n";
+	}
+};
+
+using FileStream = sp::io::Stream<sp::io::FileTag, sp::PacketDispatcher, sp::PacketFactory, sp::option::ZlibCompress>;
+
+int main() {
+	auto handler = std::make_shared<CustomPacketHandler>();
+
+	FileStream stream(sp::io::File{"test.txt", sp::io::FileTag::In | sp::io::FileTag::Out}, {});
+	stream.GetDispatcher().RegisterHandler(PacketId::Disconnect, handler);
+	stream.GetDispatcher().RegisterHandler(PacketId::KeepAlive, handler);
+
+	stream.SendMessage(KeepAlivePacket{96});
+	stream.SendMessage(KeepAlivePacket{69});
+	stream.SendMessage(DisconnectPacket{
+		"This is in the "
+		"fiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiile !"});
+	stream.GetOption<sp::option::ZlibCompress>().m_Enabled = false;
+	stream.SendMessage(DisconnectPacket{
+		"This is in the "
+		"fiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiile !"});
+
+	stream.RecieveMessages();
+
+	return 0;
+}

test/test_io.cpp

@@ -0,0 +1,40 @@
+#include <iostream>
+
+#include <examples/PacketExample.h>
+#include <sp/io/Memory.h>
+
+using DataBufferStream = sp::io::Stream<sp::io::MemoryTag, sp::PacketDispatcher, sp::PacketFactory>;
+
+class CustomPacketHandler : public sp::PacketHandler {
+	void Handle(const KeepAlivePacket& packet) {
+		std::cout << "KeepAlive handled ! " << packet.GetKeepAliveId() << "\n";
+	}
+
+	void Handle(const DisconnectPacket& packet) {
+		std::cout << "Disconnect handled ! " << packet.GetReason() << "\n";
+	}
+
+	void Handle(const UpgradeTowerPacket& packet) {
+		std::cout << "UpgradeTower handled !\n";
+	}
+};
+
+int main() {
+	auto handler = std::make_shared<CustomPacketHandler>();
+
+	DataBufferStream stream;
+	stream.GetDispatcher().RegisterHandler(PacketId::Disconnect, handler);
+
+	// this should not be dispatched
+	stream.SendMessage(KeepAlivePacket{96});
+	stream.RecieveMessages();
+
+	stream.GetDispatcher().RegisterHandler(PacketId::KeepAlive, handler);
+
+	stream.SendMessage(KeepAlivePacket{69});
+	stream.RecieveMessages();
+	stream.SendMessage(DisconnectPacket{"A valid reason"});
+	stream.RecieveMessages();
+
+	return 0;
+}

test/test_packets.cpp

@@ -3,6 +3,9 @@
 #include <examples/PacketExample.h>
 #include <memory>
 
+#include <sp/default/DefaultPacketDispatcher.h>
+#include <sp/extensions/Extensions.h>
+
 class KeepAliveHandler : public sp::PacketHandler {
 	void Handle(const KeepAlivePacket& packet) {
 		std::cout << "KeepAlive handled !\n";
@@ -22,11 +25,10 @@ int main() {
 
 	sp::PacketMessage* msg = upgradeTower.get();
 
-	KeepAliveHandler handler;
+	auto handler = std::make_shared<KeepAliveHandler>();
-	msg->Dispatch(handler);
+	msg->Dispatch(*handler);
 
-	sp::DataBuffer buffer;
+	sp::DataBuffer buffer = msg->Write();
-	msg->Write(buffer);
 
 	std::uint8_t msgId;
 	buffer >> msgId;
@@ -34,7 +36,7 @@ int main() {
 	auto upgradeTower2 = std::make_unique<UpgradeTowerPacket>();
 	upgradeTower2->Read(buffer);
 
-	std::cout << "Test : " << (unsigned) upgradeTower2->GetTowerId() << "\n";
+	std::cout << "Test : " << (unsigned)upgradeTower2->GetTowerId() << "\n";
 
 	sp::PacketFactory factory;
 	auto packet = factory.CreateMessage(msgId);
@@ -43,7 +45,13 @@ int main() {
 		return 1;
 	}
 	std::cout << (unsigned)packet->GetId() << std::endl;
-	packet->Dispatch(handler);
+	packet->Dispatch(*handler);
+
+	sp::PacketDispatcher dispatcher;
+	dispatcher.RegisterHandler(PacketId::KeepAlive, handler);
+	dispatcher.Dispatch(*packet);
+	dispatcher.UnregisterHandler(PacketId::KeepAlive, handler);
+	dispatcher.UnregisterHandler(handler);
 
 	return 0;
 }

xmake.lua

@@ -2,15 +2,74 @@ add_rules("mode.debug", "mode.release")
 
 set_languages("c++17")
 
-add_requires("enet6")
+local modules = {
+    Compression = {
+        Option = "zlib",
+        Deps = {"zlib"},
+        Includes = {"include/(sp/extensions/Compress.h)"},
+        Sources = {"src/sp/extensions/Compress.cpp"}
+    },
+    Encryption = {
+        Option = "ssl",
+        Deps = {"openssl"},
+        Includes = {"include/(sp/extensions/Encrypt.h)"},
+        Sources = {"src/sp/extensions/Encrypt.cpp"}
+    }
+}
 
-target("SimpleProtocolLib")
+-- Map modules to options
-    add_includedirs("include", {public = true})
+for name, module in table.orderpairs(modules) do
-    set_kind("binary")
+	if module.Option then
-    add_files("src/**.cpp")
+		option(module.Option, { description = "Enables the " .. name .. " module", default = true, category = "Modules" })
-    add_packages("enet6", {public = true})
+    end
+end
 
+-- Add modules requirements
+for name, module in table.orderpairs(modules) do
+	if module.Deps then
+        add_requires(module.Deps)
+    end
+end
 
+-- Add modules targets
+for name, module in table.orderpairs(modules) do
+	if module.Deps and has_config(module.Option) then
+        target("SimpleProtocol-" .. name)
+            add_includedirs("include")
+            for _, include in table.orderpairs(module.Includes) do
+                add_headerfiles(include)
+            end
+            for _, source in table.orderpairs(module.Sources) do
+                add_files(source)
+            end
+            for _, package in table.orderpairs(module.Deps) do
+                add_packages(package)
+            end
+            set_group("Library")
+            set_kind("$(kind)")
+    end
+end
+
+target("SimpleProtocol")
+    add_includedirs("include")
+    add_files("src/sp/**.cpp")
+    
+    local includeFolders = {"common", "default", "io", "protocol"}
+    for _, folder in ipairs(includeFolders) do
+        add_headerfiles("include/(sp/" .. folder .. "/**.h)")
+    end
+
+    -- adding extensions
+    for name, module in table.orderpairs(modules) do
+	    if module.Deps and has_config(module.Option) then
+            add_deps("SimpleProtocol-" .. name)
+        end
+    end
+
+    -- we don't want extensions
+    remove_files("src/sp/extensions/**.cpp")
+    set_group("Library")
+    set_kind("$(kind)")
 
 -- Tests
 for _, file in ipairs(os.files("test/**.cpp")) do
@@ -19,79 +78,9 @@ for _, file in ipairs(os.files("test/**.cpp")) do
         set_kind("binary")
 
         add_files(file)
+        add_includedirs("include")
 
-        set_default(false)
+        add_deps("SimpleProtocol")
-
-        add_deps("SimpleProtocolLib")
 
         add_tests("compile_and_run")
 end
---
--- If you want to known more usage about xmake, please see https://xmake.io
---
--- ## FAQ
---
--- You can enter the project directory firstly before building project.
---
---   $ cd projectdir
---
--- 1. How to build project?
---
---   $ xmake
---
--- 2. How to configure project?
---
---   $ xmake f -p [macosx|linux|iphoneos ..] -a [x86_64|i386|arm64 ..] -m [debug|release]
---
--- 3. Where is the build output directory?
---
---   The default output directory is `./build` and you can configure the output directory.
---
---   $ xmake f -o outputdir
---   $ xmake
---
--- 4. How to run and debug target after building project?
---
---   $ xmake run [targetname]
---   $ xmake run -d [targetname]
---
--- 5. How to install target to the system directory or other output directory?
---
---   $ xmake install
---   $ xmake install -o installdir
---
--- 6. Add some frequently-used compilation flags in xmake.lua
---
--- @code
---    -- add debug and release modes
---    add_rules("mode.debug", "mode.release")
---
---    -- add macro definition
---    add_defines("NDEBUG", "_GNU_SOURCE=1")
---
---    -- set warning all as error
---    set_warnings("all", "error")
---
---    -- set language: c99, c++11
---    set_languages("c99", "c++11")
---
---    -- set optimization: none, faster, fastest, smallest
---    set_optimize("fastest")
---
---    -- add include search directories
---    add_includedirs("/usr/include", "/usr/local/include")
---
---    -- add link libraries and search directories
---    add_links("tbox")
---    add_linkdirs("/usr/local/lib", "/usr/lib")
---
---    -- add system link libraries
---    add_syslinks("z", "pthread")
---
---    -- add compilation and link flags
---    add_cxflags("-stdnolib", "-fno-strict-aliasing")
---    add_ldflags("-L/usr/local/lib", "-lpthread", {force = true})
---
--- @endcode
---
-