clean up namespaces

include/examples/DisconnectPacket.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <sp/default/DefaultPacket.h>
+#include <sp/protocol/Field.h>
+#include <sp/protocol/MessageBase.h>
+
+enum DisconnectPacketFields {
+	Reason = 0
+};
+
+using DisconnectFields = std::tuple<std::string /*Reason*/>;
+
+DeclarePacket(Disconnect);

include/examples/PacketExample.h

@@ -1,11 +1,15 @@
 #pragma once
 
 enum PacketId {
-	KeepAlive
+	KeepAlive = 0,
+	Disconnect,
 };
 
 #include <examples/KeepAlivePacket.h>
+#include <examples/DisconnectPacket.h>
 
-using AllPackets = std::tuple<KeepAlivePacket>;
+// they must be in the same order !
+using AllPackets = std::tuple<KeepAlivePacket, DisconnectPacket>;
 
 #include <sp/default/DefaultPacketHandler.h>
+#include <sp/default/DefaultPacketFactory.h>

include/sp/common/Templates.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <cstdint>
+
+namespace sp {
+
+/// @brief Concat multiple tuples in one big tuple
+/// @tparam ...input_t Multiple std::tuple types to concat
+template <typename... input_t>
+using tuple_cat_t = decltype(std::tuple_cat(std::declval<input_t>()...));
+
+}  // namespace sp

include/sp/default/DefaultPacketFactory.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <sp/protocol/MessageFactory.h>
+
+namespace sp {
+using PacketFactory = sp::MessageFactory<sp::PacketMessage, AllPackets>;
+}  // namespace sp

include/sp/protocol/Field.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <sp/common/DataBuffer.h>
-#include <sp/protocol/Templates.h>
+#include <sp/common/Templates.h>
 
 namespace sp {
 
@@ -63,6 +63,8 @@ class FieldWriter {
 	DataBuffer& m_Buffer;
 };
 
+namespace details {
+
 template <typename... TFields>
 struct FieldsBuilder {};
 
@@ -71,15 +73,15 @@ struct FieldsBuilder<> {
 	using Type = std::tuple<>;
 };
 
-template<typename... TFields>
+template <typename... TFields>
 struct FieldsBuilder<std::tuple<TFields...>> {
 	using Type = typename FieldsBuilder<TFields...>::Type;
 };
 
-
 template <typename TField, typename... TFields>
 struct FieldsBuilder<TField, TFields...> {
 	using Type = sp::tuple_cat_t<std::tuple<Field<TField>>, typename FieldsBuilder<TFields...>::Type>;
 };
+}  // namespace details
 
 }  // namespace sp

include/sp/protocol/Message.h

@@ -5,9 +5,9 @@
 namespace sp {
 
 template <typename... TOptions>
-class Message : public option::MessageInterfaceBuilder<TOptions...>::Type {
+class Message : public details::MessageInterfaceBuilder<TOptions...>::Type {
   public:
-	using ParsedOptions = typename option::MessageInterfaceBuilder<TOptions...>::ParsedOptions;
+	using ParsedOptions = typename details::MessageInterfaceBuilder<TOptions...>::ParsedOptions;
 };
 
 }  // namespace sp

include/sp/protocol/MessageBase.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <sp/protocol/Message.h>
-#include <sp/protocol/Templates.h>
 
 namespace sp {
 namespace option {
@@ -22,6 +21,9 @@ struct FieldsImpl {};
 }  // namespace option
 
 
+namespace details {
+
+
 
 
 
@@ -92,9 +94,9 @@ class MessageImplDispatchBase : public TBase {
 template <typename TBase, typename TFields>
 class MessageImplFieldsBase : public TBase {
   public:
-	using AllFields = typename FieldsBuilder<TFields>::Type;
+	using AllFields = typename details::FieldsBuilder<TFields>::Type;
 
-	template<typename... Args>
+	template <typename... Args>
 	void Construct(Args... args) {
 		m_Fields = std::make_tuple(args...);
 	}
@@ -106,7 +108,7 @@ class MessageImplFieldsBase : public TBase {
 		return m_Fields;
 	}
 
-	template<std::size_t FIndex>
+	template <std::size_t FIndex>
 	auto& GetField() {
 		return std::get<FIndex>(GetFields()).GetValue();
 	}
@@ -119,7 +121,7 @@ template <typename TBase>
 class MessageImplFieldsReadBase : public TBase {
   protected:
 	void ReadImpl(DataBuffer& buffer) override {
-		//TODO: add endianess
+		// TODO: add endianess
 		auto& allFields = TBase::GetFields();
 		std::apply(FieldReader{buffer}, allFields);
 	}
@@ -129,7 +131,7 @@ template <typename TBase>
 class MessageImplFieldsWriteBase : public TBase {
   protected:
 	void WriteImpl(DataBuffer& buffer) override {
-		//TODO: add endianess + write ID
+		// TODO: add endianess + write ID
 		auto& allFields = TBase::GetFields();
 		std::apply(FieldWriter{buffer}, allFields);
 	}
@@ -274,11 +276,10 @@ struct MessageImplBuilder {
 	using Type = Base6;
 };
 
-
+}  // namespace details
 
 template <typename TBase, typename... TOptions>
-class MessageBase : public MessageImplBuilder<TBase, TOptions...>::Type {};
-
+class MessageBase : public details::MessageImplBuilder<TBase, TOptions...>::Type {};
 
 
 }  // namespace sp

include/sp/protocol/MessageFactory.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <array>
+#include <functional>
+#include <iostream>
+#include <memory>
+
+namespace sp {
+
+namespace details {
+
+template <typename TBase>
+using ArrayType = std::vector<std::function<std::unique_ptr<TBase>(void)>>;
+
+
+
+template <typename TBase, typename... TMessages>
+struct ArrayFiller {};
+
+template <typename TBase, typename... TMessages>
+struct ArrayFiller<TBase, std::tuple<TMessages...>> {
+	static void ArrayAppend(details::ArrayType<TBase>& array) {
+		ArrayFiller<TBase, TMessages...>::ArrayAppend(array);
+	}
+};
+
+template <typename TBase, typename TMessage, typename... TMessages>
+struct ArrayFiller<TBase, TMessage, TMessages...> {
+	static void ArrayAppend(details::ArrayType<TBase>& array) {
+		ArrayFiller<TBase, TMessage>::ArrayAppend(array);
+		ArrayFiller<TBase, TMessages...>::ArrayAppend(array);
+	}
+};
+
+template <typename TBase, typename TMessage>
+struct ArrayFiller<TBase, TMessage> {
+	static void ArrayAppend(details::ArrayType<TBase>& array) {
+		array.push_back([]() -> std::unique_ptr<TBase> { return std::make_unique<TMessage>(); });
+	}
+};
+
+}  // namespace details
+
+template <typename TBase, typename TTMessages>
+class MessageFactory {
+  public:
+	using IdType = typename TBase::MsgIdType;
+
+	MessageFactory() {
+		details::ArrayFiller<TBase, TTMessages>::ArrayAppend(m_Factory);
+	}
+
+	std::unique_ptr<TBase> CreateMessage(IdType id) {
+		if (id >= m_Factory.size())
+			return nullptr;
+		return m_Factory.at(id)();
+	}
+
+  private:
+	details::ArrayType<TBase> m_Factory;
+};
+
+
+
+}  // namespace sp

include/sp/protocol/MessageInterfaceBuilder.h

@@ -3,7 +3,7 @@
 #include <sp/protocol/MessageInterfaces.h>
 
 namespace sp {
-namespace option {
+namespace details {
 
 class EmptyBase {};
 
@@ -34,5 +34,5 @@ struct MessageInterfaceBuilder {
 	using Type = Base6;
 };
 
-}  // namespace option
+}  // namespace details
 }  // namespace sp

include/sp/protocol/MessageInterfaces.h

@@ -3,7 +3,7 @@
 #include <sp/protocol/Options.h>
 
 namespace sp {
-namespace option {
+namespace details {
 
 template <typename... TOptions>
 struct MessageInterfaceParsedOptions {};
@@ -23,34 +23,34 @@ struct MessageInterfaceParsedOptions<> {
 
 
 template <typename T, typename... TOptions>
-struct MessageInterfaceParsedOptions<MsgIdType<T>, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
+struct MessageInterfaceParsedOptions<option::MsgIdType<T>, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
 	static const bool HasMsgIdType = true;
 	using MsgIdType = T;
 };
 
 template <typename... TOptions>
-struct MessageInterfaceParsedOptions<LittleEndian, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
+struct MessageInterfaceParsedOptions<option::LittleEndian, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
 	static const bool HasLittleEndian = true;
 };
 
 template <typename... TOptions>
-struct MessageInterfaceParsedOptions<ReadOperations, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
+struct MessageInterfaceParsedOptions<option::ReadOperations, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
 	static const bool HasReadOperations = true;
 };
 
 template <typename... TOptions>
-struct MessageInterfaceParsedOptions<WriteOperations, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
+struct MessageInterfaceParsedOptions<option::WriteOperations, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
 	static const bool HasWriteOperations = true;
 };
 
 template <typename T, typename... TOptions>
-struct MessageInterfaceParsedOptions<Handler<T>, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
+struct MessageInterfaceParsedOptions<option::Handler<T>, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
 	static const bool HasHandler = true;
-	using HandlerType = Handler<T>;
+	using HandlerType = option::Handler<T>;
 };
 
 template <typename... TOptions>
-struct MessageInterfaceParsedOptions<ValidCheckInterface, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
+struct MessageInterfaceParsedOptions<option::ValidCheckInterface, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
 	static const bool HasValid = true;
 };
 
@@ -239,5 +239,5 @@ template <typename TBase>
 struct MessageInterfaceProcessValid<TBase, false> {
 	using Type = TBase;
 };
-}  // namespace option
+}  // namespace details
 }  // namespace sp

include/sp/protocol/Templates.h

@@ -1,37 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-namespace sp {
-
-/// @brief Default case, see field_index specialization for implementation details
-template <size_t N, typename T, template <size_t, typename> typename U, typename = void>
-static constexpr size_t field_index = 0;
-
-/// @brief A templated size_t that counts the number of existing classes U with a "field_name" member
-/// @tparam N Current counter for recursion (user should always call it with 0)
-/// @tparam T Can be any type, must be different for each field we want to be counted later (used because we can't have a empty
-/// template<> specialization nested in a class)
-/// @tparam U The templated class that will be searched for match
-template <size_t N, typename T, template <size_t, typename> typename U>
-static constexpr size_t field_index<N, T, U, std::void_t<decltype(U<N, T>::field_name)>> = 1 + field_index<N + 1, T, U>;
-
-/// @brief Concat multiple tuples in one big tuple
-/// @tparam ...input_t Multiple std::tuple types to concat
-template <typename... input_t>
-using tuple_cat_t = decltype(std::tuple_cat(std::declval<input_t>()...));
-
-template <typename T, typename Tuple>
-constexpr bool tuple_contains_type = false;
-template <typename T, typename... Ts>
-constexpr bool tuple_contains_type<T, std::tuple<Ts...>> = std::disjunction_v<std::is_same<T, Ts>...>;
-
-template <typename T, typename Tuple>
-constexpr int get_tuple_index = 0;
-template <typename T, typename... Rest>
-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...>>;
-
-
-}  // namespace sp

src/main.cpp

@@ -7,6 +7,10 @@ class KeepAliveHandler : public sp::PacketHandler {
 	void Handle(KeepAlivePacket& packet) {
 		std::cout << "KeepAlive handled !\n";
 	}
+
+	void Handle(DisconnectPacket& packet) {
+		std::cout << "Disconnect handled !\n";
+	}
 };
 
 int main() {
@@ -24,7 +28,15 @@ int main() {
 
 	std::cout << "KeepAlive2 : " << keepAlive2->GetField<KeepAliveId>() << "\n";
 
-	//TODO: write ID and factory
+	//TODO: write ID
+	sp::PacketFactory factory;
+	auto packet = factory.CreateMessage(Disconnect);
+	if (packet == nullptr) {
+		std::cout << "Mauvais ID !\n";
+		return 1;
+	}
+	std::cout << (unsigned) packet->GetId() << std::endl;
+	packet->Dispatch(handler);
 
 	return 0;
 }