oui

include/examples/DisconnectPacket.h

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

include/examples/KeepAlivePacket.h

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

include/examples/UpgradeTowerPacket.h

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

include/sp/default/DefaultPacket.h

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

include/sp/protocol/Field.h

@@ -45,12 +45,6 @@ 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) {}
@@ -114,6 +108,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/MessageBase.h

@@ -2,15 +2,344 @@
 
 #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/message/MessageImplBuilder.h

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

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

@@ -1,93 +0,0 @@
-#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/MessagesImpl.h

@@ -1,160 +0,0 @@
-#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) 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();
-	}
-
-	// 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(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;
-	}
-};
-
-}  // namespace details
-}  // 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_headerfiles("include/(sp/**.h)")
-    set_group("Library")
-    add_files("src/sp/**.cpp")
-    set_kind("$(kind)")
+    add_includedirs("include", {public = true})
+    set_kind("binary")
+    add_files("src/**.cpp")
+    add_packages("enet6", {public = true})
+
+
 
 -- 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
+--
+