constructor for packets

include/sp/default/DefaultPacket.h

@@ -1,22 +1,26 @@
 #pragma once
 
-#include <sp/protocol/Message.h>
 #include <sp/protocol/GenericHandler.h>
+#include <sp/protocol/Message.h>
 
 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::WriteOperations,									// add write() operation
 	option::Handler<PacketHandler>								// add dispatch() operation
 	>;
 
-#define DeclarePacket(packetName) class packetName##Packet : public sp::MessageBase<sp::PacketMessage,\
+#define DeclarePacket(packetName)                                                                                                     \
-	sp::option::StaticNumIdImpl<packetName>,		\
+	class packetName##Packet : public sp::MessageBase<sp::PacketMessage, sp::option::StaticNumIdImpl<packetName>,                     \
-							sp::option::DispatchImpl<packetName##Packet>,	\
+								   sp::option::DispatchImpl<packetName##Packet>, sp::option::FieldsImpl<packetName##Fields>> {        \
-							sp::option::FieldsImpl<packetName##Fields>		\
+	  public:                                                                                                                         \
-							> {}
+		packetName##Packet() {}                                                                                                       \
+		template <typename... Args>                                                                                                   \
+		packetName##Packet(Args... args) {                                                                                            \
+			Construct(args...);                                                                                                       \
+		}                                                                                                                             \
+	}
 
 }  // namespace sp

include/sp/protocol/MessageBase.h

@@ -54,7 +54,7 @@ struct MessageImplParsedOptions<option::DispatchImpl<TActual>, TOptions...> : pu
 template <typename TFields, typename... TOptions>
 struct MessageImplParsedOptions<option::FieldsImpl<TFields>, TOptions...> : public MessageImplParsedOptions<TOptions...> {
 	static const bool HasFieldsImpl = true;
-	using Fields = typename FieldsBuilder<TFields>::Type;
+	using Fields = TFields;
 };
 
 
@@ -92,7 +92,12 @@ class MessageImplDispatchBase : public TBase {
 template <typename TBase, typename TFields>
 class MessageImplFieldsBase : public TBase {
   public:
-	using AllFields = TFields;
+	using AllFields = typename FieldsBuilder<TFields>::Type;
+
+	template<typename... Args>
+	void Construct(Args... args) {
+		m_Fields = std::make_tuple(args...);
+	}
 
 	AllFields& GetFields() {
 		return m_Fields;
@@ -107,7 +112,7 @@ class MessageImplFieldsBase : public TBase {
 	}
 
   private:
-	TFields m_Fields;
+	AllFields m_Fields;
 };
 
 template <typename TBase>
@@ -116,7 +121,7 @@ class MessageImplFieldsReadBase : public TBase {
 	void ReadImpl(DataBuffer& buffer) override {
 		//TODO: add endianess
 		auto& allFields = TBase::GetFields();
-		tupleForEach(allFields, FieldReader{buffer});
+		std::apply(FieldReader{buffer}, allFields);
 	}
 };
 
@@ -126,7 +131,7 @@ class MessageImplFieldsWriteBase : public TBase {
 	void WriteImpl(DataBuffer& buffer) override {
 		//TODO: add endianess
 		auto& allFields = TBase::GetFields();
-		tupleForEach(allFields, FieldWriter{buffer});
+		std::apply(FieldWriter{buffer}, allFields);
 	}
 };
 

include/sp/protocol/Templates.h

@@ -33,54 +33,5 @@ constexpr int get_tuple_index<T, std::tuple<T, Rest...>> = 0;
 template <typename T, typename First, typename... Rest>
 constexpr int get_tuple_index<T, std::tuple<First, Rest...>> = 1 + get_tuple_index<T, std::tuple<Rest...>>;
 
-// Template black magic to loop at compile time
-template <std::size_t... indices, class LoopBody>
-void loop_impl(std::index_sequence<indices...>, LoopBody&& loop_body) {
-	(loop_body(std::integral_constant<std::size_t, indices>{}), ...);
-}
-
-template <std::size_t N, class LoopBody>
-void loop(LoopBody&& loop_body) {
-	loop_impl(std::make_index_sequence<N>{}, std::forward<LoopBody>(loop_body));
-}
-
-namespace details {
-template <std::size_t TRem>
-class TupleForEachHelper {
-  public:
-	template <typename TTuple, typename TFunc>
-	static void exec(TTuple&& tuple, TFunc&& func) {
-		using Tuple = typename std::decay<TTuple>::type;
-		static const std::size_t TupleSize = std::tuple_size<Tuple>::value;
-		static_assert(TRem <= TupleSize, "Incorrect parameters");
-
-		// Invoke function with current element
-		static const std::size_t Idx = TupleSize - TRem;
-		func(std::get<Idx>(std::forward<TTuple>(tuple)));
-
-		// Compile time recursion - invoke function with the remaining elements
-		TupleForEachHelper<TRem - 1>::exec(std::forward<TTuple>(tuple), std::forward<TFunc>(func));
-	}
-};
-
-template <>
-class TupleForEachHelper<0> {
-  public:
-	// Stop compile time recursion
-	template <typename TTuple, typename TFunc>
-	static void exec(TTuple&& tuple, TFunc&& func) {
-		static_cast<void>(tuple);
-		static_cast<void>(func);
-	}
-};
-}  // namespace details
-
-template <typename TTuple, typename TFunc>
-void tupleForEach(TTuple&& tuple, TFunc&& func) {
-	using Tuple = typename std::decay<TTuple>::type;
-	static const std::size_t TupleSize = std::tuple_size<Tuple>::value;
-
-	details::TupleForEachHelper<TupleSize>::exec(std::forward<TTuple>(tuple), std::forward<TFunc>(func));
-}
 
 }  // namespace sp

src/main.cpp

@@ -10,14 +10,12 @@ class KeepAliveHandler : public sp::PacketHandler {
 };
 
 int main() {
-	auto keepAlive = std::make_unique<KeepAlivePacket>();
+	auto keepAlive = std::make_unique<KeepAlivePacket>(69);
 	sp::PacketMessage* msg = keepAlive.get();
 	
 	KeepAliveHandler handler;
 	msg->Dispatch(handler);
 
-	//TODO: constructor
-	keepAlive->GetField<KeepAliveId>() = 69;
 	sp::DataBuffer buffer;
 	msg->Write(buffer);