fix alignment + refactor

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

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/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/default/DefaultPacket.h

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