better example

include/examples/PacketExample.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <sp/default/DefaultPacket.h>
+#include <sp/protocol/Field.h>
+#include <sp/protocol/MessageBase.h>
+
+enum PacketId {
+	KeepAlive = 0,
+};
+
+using KeepAliveFields = std::tuple<sp::Field<std::uint64_t>>;
+
+class KeepAlivePacket : public sp::MessageBase<sp::PacketMessage,
+							sp::option::StaticNumIdImpl<KeepAlive>,		// provide idImpl() if needed
+							sp::option::DispatchImpl<KeepAlivePacket>,	// provide dispatchImpl() if needed
+							sp::option::FieldsImpl<KeepAliveFields>		// provide access to fields
+							> {};
+
+using AllPackets = std::tuple<KeepAlivePacket>;
+
+#include <sp/default/DefaultPacketHandler.h>

include/sp/Types.h

@@ -1,9 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-namespace sp {
-
-using PeerID = std::uint16_t;
-
-}  // namespace sp

include/sp/default/DefaultPacket.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <sp/protocol/Message.h>
+#include <sp/protocol/GenericHandler.h>
+
+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::Handler<PacketHandler>								// add dispatch() operation
+	>;
+
+}  // namespace sp

include/sp/default/DefaultPacketHandler.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <sp/protocol/GenericHandler.h>
+
+// the tuple AllPackets must be defined !
+
+namespace sp {
+class PacketHandler : public sp::GenericHandler<PacketMessage, AllPackets> {};
+}  // namespace sp

include/sp/protocol/Message.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <sp/MessageInterfaceBuilder.h>
+#include <sp/protocol/MessageInterfaceBuilder.h>
 
 namespace sp {
 

include/sp/protocol/MessageBase.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <sp/Message.h>
-#include <sp/Templates.h>
+#include <sp/protocol/Message.h>
+#include <sp/protocol/Templates.h>
 
 namespace sp {
 namespace option {
@@ -261,7 +261,7 @@ struct MessageImplBuilder {
 	using Base5 = typename MessageImplProcessWriteFields<Base4, HasWriteImpl>::Type;
 
 	// Provide ValidImpl() if possible
-	static const bool HasValidImpl = InterfaceOptions::HasWriteOperations && ImplOptions::HasFieldsImpl;
+	static const bool HasValidImpl = InterfaceOptions::HasValid && ImplOptions::HasFieldsImpl;
 	using Base6 = typename MessageImplProcessValidFields<Base5, HasValidImpl>::Type;
 
 	// The last BaseN must be taken as final type.

include/sp/protocol/MessageInterfaceBuilder.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <sp/MessageInterfaces.h>
+#include <sp/protocol/MessageInterfaces.h>
 
 namespace sp {
 namespace option {

include/sp/protocol/MessageInterfaces.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <sp/Options.h>
+#include <sp/protocol/Options.h>
 
 namespace sp {
 namespace option {

src/main.cpp

@@ -1,70 +1,17 @@
 #include <iostream>
 
-#include <sp/Field.h>
-#include <sp/GenericHandler.h>
-#include <sp/MessageBase.h>
-
 #include <memory>
+#include <examples/PacketExample.h>
 
-enum MyMsgId {
-	MyMsgId_Msg1,
-	MyMsgId_Msg2,
-};
-
-class MyHandler;  // forward declaration of the handler class.
-
-using MyMessage = sp::Message<sp::option::MsgIdType<MyMsgId>,  // add id() operation
-	sp::option::ReadOperations,								   // add read() operation
-	sp::option::WriteOperations,							   // add write() operation
-	sp::option::Handler<MyHandler>,							   // add dispatch() operation
-	sp::option::ValidCheckInterface,						   // add valid() operation
-	sp::option::LittleEndian								   // use little endian for serialisation
-	>;
-
-
-
-using ActualMessage1Fields = std::tuple<sp::Field<std::uint16_t>, sp::Field<std::int8_t>>;
-
-
-
-template <typename TMessageInterface>
-class ActualMessage1 : public sp::MessageBase<TMessageInterface,
-						   sp::option::StaticNumIdImpl<MyMsgId_Msg1>,					 // provide idImpl() if needed
-						   sp::option::DispatchImpl<ActualMessage1<TMessageInterface>>,	 // provide dispatchImpl() if needed
-						   sp::option::FieldsImpl<ActualMessage1Fields>					 // provide access to fields and
-																						 // readImpl(), writeImpl(),
-																						 // lengthImpl(), validImpl()
-																						 // functions if needed
-						   > {};
-
-using MyActualMessage1 = ActualMessage1<MyMessage>;
-
-using AllMessages = std::tuple<MyActualMessage1>;
-
-class MyHandler : public sp::GenericHandler<MyMessage, AllMessages> {
-  public:
-	void Handle(MyActualMessage1& msg) {
-		std::cout << "Got message 1 !\n";
+class KeepAliveHandler : public sp::PacketHandler {
+	void Handle(KeepAlivePacket& packet) {
+		std::cout << "KeepAlive handled !\n";
 	}
 };
 
-
 int main() {
-	MyMessage::MsgIdType test;
-	auto yes = std::make_unique<ActualMessage1<MyMessage>>();
-	auto& fields = yes->GetFields();
-
-	std::get<0>(fields) = 69;
-	std::get<1>(fields) = 42;
-
-	MyHandler handlerTest;
-	yes->Dispatch(handlerTest);
-	sp::DataBuffer buffer;
-	yes->Write(buffer);
-
-	auto yesyes = std::make_unique<ActualMessage1<MyMessage>>();
-	yesyes->Read(buffer);
-	std::cout << "Field 1 : " << yesyes->GetField<0>() << std::endl;
-	std::cout << "Field 2 : " << (unsigned) yesyes->GetField<1>() << std::endl;
+	std::unique_ptr<sp::PacketMessage> msg = std::make_unique<KeepAlivePacket>();
+	KeepAliveHandler handler;
+	msg->Dispatch(handler);
 	return 0;
 }