refactor: split message classes

README.md

@@ -1,10 +0,0 @@
-# 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/sp/common/ByteSwapping.h

@@ -1,10 +1,26 @@
 #pragma once
 
+#ifdef _WIN32
+#include <winsock2.h>
+#else
+#include <arpa/inet.h>
+#endif
+
 #include <cstdint>
 
 namespace sp {
 
-bool IsSystemBigEndian();
+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;
+}
 
 /**
  * \brief Serialize value to (network byte order) big endian
@@ -13,13 +29,21 @@ 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
@@ -28,13 +52,21 @@ 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
@@ -43,12 +75,18 @@ 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,7 +13,6 @@
 #include <string>
 #include <sp/common/VarInt.h>
 #include <vector>
-#include <map>
 
 namespace sp {
 
@@ -89,19 +88,6 @@ 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
@@ -154,23 +140,6 @@ 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.insert({newKey, newValue});
-		}
-		return *this;
-	}
-
 	/**
 	 * \brief Read an array from the buffer
 	 */

include/sp/default/DefaultPacket.h

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

include/sp/protocol/Field.h

@@ -114,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 sp

include/sp/protocol/message/MessageInterfacesImpl.h

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

include/sp/protocol/message/MessagesImpl.h

@@ -26,8 +26,8 @@ class MessageImplDispatchBase : public TBase {
 	using Handler = typename TBase::HandlerType;
 
   protected:
-	virtual void DispatchImpl(Handler& handler) const override {
+	virtual void DispatchImpl(Handler& handler) override {
-		handler.Handle(static_cast<const TActual&>(*this));
+		handler.Handle(static_cast<TActual&>(*this));
 	}
 };
 
@@ -113,13 +113,13 @@ class MessageImplFieldsWriteBase : public TBase {
   private:
 	// normal writing
 	template <typename TField>
-	void WriteField(const Field<TField, 0>& field, DataBuffer& buffer) const {
+	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(const Field<TField, IAlignment>& field, TFieldType& data, std::size_t offset) const {
+	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;
@@ -127,7 +127,7 @@ class MessageImplFieldsWriteBase : public TBase {
 
 	// writing bitfield
 	template <typename TContainer, typename TFirst, typename... TFields>
-	void WriteField(const Field<BitField<TContainer, TFirst, TFields...>, 0>& field, DataBuffer& buffer) const {
+	void WriteField(Field<BitField<TContainer, TFirst, TFields...>, 0>& field, DataBuffer& buffer) {
 		TContainer data = 0;
 		std::size_t offset = 0;
 		TupleForEach(
@@ -139,9 +139,9 @@ class MessageImplFieldsWriteBase : public TBase {
 		this->WriteData(data, buffer);
 	}
 
-	void WriteImpl(DataBuffer& buffer) const override {
+	void WriteImpl(DataBuffer& buffer) override {
 		auto& allFields = this->GetFields();
-		TupleForEach([&buffer, this](const auto& field) { this->WriteField(field, buffer); }, allFields);
+		TupleForEach([&buffer, this](auto& field) { this->WriteField(field, buffer); }, allFields);
 	}
 };
 

src/sp/common/ByteSwapping.cpp

@@ -1,74 +0,0 @@
-#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

xmake.lua

@@ -2,12 +2,15 @@ add_rules("mode.debug", "mode.release")
 
 set_languages("c++17")
 
+add_requires("enet6")
+
 target("SimpleProtocolLib")
-    add_includedirs("include")
+    add_includedirs("include", {public = true})
-    add_headerfiles("include/(sp/**.h)")
+    set_kind("binary")
-    set_group("Library")
+    add_files("src/**.cpp")
-    add_files("src/sp/**.cpp")
+    add_packages("enet6", {public = true})
-    set_kind("$(kind)")
+
+
 
 -- Tests
 for _, file in ipairs(os.files("test/**.cpp")) do
@@ -16,9 +19,79 @@ for _, file in ipairs(os.files("test/**.cpp")) do
         set_kind("binary")
 
         add_files(file)
-        add_includedirs("include")
+
+        set_default(false)
 
         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
+--
+