refactor

include/sp/protocol/message/MessageInterfaceBuilder.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <sp/protocol/message/MessageInterfaces.h>
+
+namespace sp {
+namespace details {
+
+class EmptyBase {};
+
+template <typename... TOptions>
+struct MessageInterfaceBuilder {
+	// Parse the options
+	using ParsedOptions = MessageInterfaceParsedOptions<TOptions...>;
+
+	// Add ID retrieval functionality if ID type was provided
+	using Base1 = typename MessageInterfaceProcessMsgId<EmptyBase, ParsedOptions, ParsedOptions::HasMsgIdType>::Type;
+
+	// Add ReadData() and WriteData(), that use the right endian
+	using Base2 = typename MessageInterfaceProcessEndian<Base1, ParsedOptions::HasLittleEndian>::Type;
+
+	// Add read functionality if Read type was provided
+	using Base3 = typename MessageInterfaceProcessRead<Base2, ParsedOptions::HasReadOperations>::Type;
+
+	// Add write functionality if Write type was provided
+	using Base4 = typename MessageInterfaceProcessWrite<Base3, ParsedOptions::HasWriteOperations>::Type;
+
+	// add dispatch functionality if Handler type was provided
+	using Base5 = typename MessageInterfaceProcessHandler<Base4, ParsedOptions, ParsedOptions::HasHandler>::Type;
+
+	// add valid functionality if Valid tpe was provided
+	using Base6 = typename MessageInterfaceProcessValid<Base5, ParsedOptions::HasValid>::Type;
+
+	// add write id functionality if write id and write was provided
+	using Base7 = typename MessageInterfaceProcessWriteId<Base6, ParsedOptions::HasWriteId && ParsedOptions::HasWriteOperations>::Type;
+
+	// The last Base6 must be taken as final type.
+	using Type = Base7;
+};
+
+}  // namespace details
+}  // namespace sp

include/sp/protocol/message/MessageInterfaceProcess.h

@@ -0,0 +1,105 @@
+#pragma once
+
+namespace sp {
+namespace details {
+
+// Build message Id
+template <typename TBase, typename TParsedOptions, bool THasMsgIdType>
+struct MessageInterfaceProcessMsgId;
+
+template <typename TBase, typename TParsedOptions>
+struct MessageInterfaceProcessMsgId<TBase, TParsedOptions, true> {
+	using Type = MessageInterfaceIdTypeBase<TBase, typename TParsedOptions::MsgIdType>;
+};
+
+template <typename TBase, typename TParsedOptions>
+struct MessageInterfaceProcessMsgId<TBase, TParsedOptions, false> {
+	using Type = TBase;
+};
+
+// Build endianess
+template <typename TBase, bool THasLittleEndian>
+struct MessageInterfaceProcessEndian;
+
+template <typename TBase>
+struct MessageInterfaceProcessEndian<TBase, true> {
+	using Type = MessageInterfaceLittleEndian<TBase>;
+};
+
+template <typename TBase>
+struct MessageInterfaceProcessEndian<TBase, false> {
+	using Type = MessageInterfaceBigEndian<TBase>;
+};
+
+// Build read
+template <typename TBase, bool THasRead>
+struct MessageInterfaceProcessRead;
+
+template <typename TBase>
+struct MessageInterfaceProcessRead<TBase, true> {
+	using Type = MessageInterfaceReadBase<TBase>;
+};
+
+template <typename TBase>
+struct MessageInterfaceProcessRead<TBase, false> {
+	using Type = TBase;
+};
+
+// Build write
+template <typename TBase, bool THasWrite>
+struct MessageInterfaceProcessWrite;
+
+template <typename TBase>
+struct MessageInterfaceProcessWrite<TBase, true> {
+	using Type = MessageInterfaceWriteBase<TBase>;
+};
+
+template <typename TBase>
+struct MessageInterfaceProcessWrite<TBase, false> {
+	using Type = TBase;
+};
+
+// Build handler
+template <typename TBase, typename TParsedOptions, bool THasHandler>
+struct MessageInterfaceProcessHandler;
+
+template <typename TBase, typename TParsedOptions>
+struct MessageInterfaceProcessHandler<TBase, TParsedOptions, true> {
+	using Type = MessageInterfaceHandlerBase<TBase, typename TParsedOptions::HandlerType>;
+};
+
+template <typename TBase, typename TParsedOptions>
+struct MessageInterfaceProcessHandler<TBase, TParsedOptions, false> {
+	using Type = TBase;
+};
+
+// Build valid
+template <typename TBase, bool THasValid>
+struct MessageInterfaceProcessValid;
+
+template <typename TBase>
+struct MessageInterfaceProcessValid<TBase, true> {
+	using Type = MessageInterfaceValidityBase<TBase>;
+};
+
+template <typename TBase>
+struct MessageInterfaceProcessValid<TBase, false> {
+	using Type = TBase;
+};
+
+// Build id writing
+template <typename TBase, bool THasValid>
+struct MessageInterfaceProcessWriteId;
+
+template <typename TBase>
+struct MessageInterfaceProcessWriteId<TBase, true> {
+	using Type = MessageInterfaceWriteIdBase<TBase>;
+};
+
+template <typename TBase>
+struct MessageInterfaceProcessWriteId<TBase, false> {
+	using Type = TBase;
+};
+
+}  // namespace details
+}  // namespace sp

include/sp/protocol/message/MessageInterfaces.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <sp/protocol/message/MessageOptions.h>
+
+#include <sp/protocol/message/MessageInterfacesOptions.h>
+#include <sp/protocol/message/MessageInterfacesImpl.h>
+#include <sp/protocol/message/MessageInterfaceProcess.h>

include/sp/protocol/message/MessageInterfacesImpl.h

@@ -0,0 +1,119 @@
+#pragma once
+
+#include <sp/common/ByteSwapping.h>
+
+namespace sp {
+namespace details {
+
+
+// ID retrieval chunk
+template <typename TBase, typename TId>
+class MessageInterfaceIdTypeBase : public TBase {
+  public:
+	using MsgIdType = TId;
+	MsgIdType GetId() const {
+		return GetIdImpl();
+	}
+
+  protected:
+	virtual MsgIdType GetIdImpl() const = 0;
+};
+
+// Big endian serialisation chunk
+template <typename TBase>
+class MessageInterfaceBigEndian : public TBase {
+  protected:
+	template <typename T>
+	void ReadData(T& value, DataBuffer& buffer) {
+		buffer >> value;
+		FromNetwork(value);
+	}
+
+	template <typename T>
+	void WriteData(T value, DataBuffer& buffer) {
+		ToNetwork(value);
+		buffer << value;
+	}
+};
+
+// Little endian serialisation chunk
+template <typename TBase>
+class MessageInterfaceLittleEndian : public TBase {
+  protected:
+	template <typename T>
+	void ReadData(T& value, DataBuffer& buffer) {
+		buffer >> value;
+		TrySwapBytes(value);
+		FromNetwork(value);
+	}
+
+	template <typename T>
+	void WriteData(const T& value, DataBuffer& buffer) {
+		ToNetwork(value);
+		TrySwapBytes(value);
+		buffer << value;
+	}
+};
+
+// Read functionality chunk
+template <typename TBase>
+class MessageInterfaceReadBase : public TBase {
+  public:
+	void Read(DataBuffer& buffer) {
+		return ReadImpl(buffer);
+	}
+
+  protected:
+	virtual void ReadImpl(DataBuffer& buffer) = 0;
+};
+
+// Write functionality chunk
+template <typename TBase>
+class MessageInterfaceWriteBase : public TBase {
+  public:
+	void Write(DataBuffer& buffer) {
+		WriteImpl(buffer);
+	}
+
+  protected:
+	virtual void WriteImpl(DataBuffer& buffer) = 0;
+};
+
+// Handler functionality chunk
+template <typename TBase, typename THandler>
+class MessageInterfaceHandlerBase : public TBase {
+  public:
+	using HandlerType = typename THandler::HandlerT;
+
+	void Dispatch(HandlerType& handler) {
+		DispatchImpl(handler);
+	}
+
+  protected:
+	virtual void DispatchImpl(HandlerType& handler) = 0;
+};
+
+// Validity functionality chunk
+template <typename TBase>
+class MessageInterfaceValidityBase : public TBase {
+  public:
+	bool Valid() const {
+		return ValidImpl();
+	}
+
+  protected:
+	virtual bool ValidImpl() const = 0;
+};
+
+// Writing id functionality chunk
+template <typename TBase>
+class MessageInterfaceWriteIdBase : public TBase {
+  public:
+	void Write(DataBuffer& buffer) {
+		this->WriteData(this->GetId(), buffer);
+		this->WriteImpl(buffer);
+	}
+};
+
+}  // namespace details
+}  // namespace sp

include/sp/protocol/message/MessageInterfacesOptions.h

@@ -0,0 +1,63 @@
+#pragma once
+
+namespace sp {
+namespace details {
+
+
+template <typename... TOptions>
+struct MessageInterfaceParsedOptions {};
+
+template <>
+struct MessageInterfaceParsedOptions<> {
+	static const bool HasMsgIdType = false;
+	static const bool HasLittleEndian = false;
+	static const bool HasReadOperations = false;
+	static const bool HasWriteOperations = false;
+	static const bool HasWriteId = false;
+	static const bool HasHandler = false;
+	static const bool HasValid = false;
+};
+
+
+
+
+
+template <typename T, typename... TOptions>
+struct MessageInterfaceParsedOptions<option::MsgIdType<T>, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
+	static const bool HasMsgIdType = true;
+	using MsgIdType = T;
+};
+
+template <typename... TOptions>
+struct MessageInterfaceParsedOptions<option::LittleEndian, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
+	static const bool HasLittleEndian = true;
+};
+
+template <typename... TOptions>
+struct MessageInterfaceParsedOptions<option::ReadOperations, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
+	static const bool HasReadOperations = true;
+};
+
+template <typename... TOptions>
+struct MessageInterfaceParsedOptions<option::WriteOperations, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
+	static const bool HasWriteOperations = true;
+};
+
+template <typename... TOptions>
+struct MessageInterfaceParsedOptions<option::WriteId, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
+	static const bool HasWriteId = true;
+};
+
+template <typename T, typename... TOptions>
+struct MessageInterfaceParsedOptions<option::Handler<T>, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
+	static const bool HasHandler = true;
+	using HandlerType = option::Handler<T>;
+};
+
+template <typename... TOptions>
+struct MessageInterfaceParsedOptions<option::ValidCheckInterface, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
+	static const bool HasValid = true;
+};
+
+}  // namespace details
+}  // namespace sp

include/sp/protocol/message/MessageOptions.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <sp/common/DataBuffer.h>
+
+namespace sp {
+namespace option {
+
+// Define type used to store message ID
+template <typename T>
+struct MsgIdType {};
+
+// Enable reading
+struct ReadOperations {};
+
+// Enable writing
+struct WriteOperations {};
+
+// Enable id writing
+struct WriteId {};
+
+// Use little endian for serialisation (instead of default big)
+struct LittleEndian {};
+
+// Include validity check in public interface
+struct ValidCheckInterface {};
+
+// Define handler class
+template <typename T>
+struct Handler {
+	using HandlerT = T;
+};
+
+}  // namespace option
+}  // namespace sp