better print override

include/examples/UpgradeTowerPacket.h

@@ -14,7 +14,8 @@ using UpgradeTowerFields = std::tuple<
 	sp::BitField<std::uint16_t, 
 		sp::Field<std::uint16_t, 12>,  		//<- m_Tower
 		sp::Field<std::uint8_t, 4>			//<- m_Upgrade
-		>
+		>,
+	sp::VarInt								//<- just for testing
 	>;
 
 DeclarePacket(UpgradeTower){

include/sp/common/Reflection.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <cxxabi.h>
+#include <string>
+
+namespace sp {
+
+template <typename T>
+std::string GetBasicClassName(const T& a_Value) {
+	int status;
+	char* demangled = abi::__cxa_demangle(typeid(a_Value).name(), 0, 0, &status);
+	if (status != 0)
+		return "";
+	return std::string(demangled);
+}
+
+template <typename T>
+std::string GetBasicClassName() {
+	int status;
+	char* demangled = abi::__cxa_demangle(typeid(T).name(), 0, 0, &status);
+	if (status != 0)
+		return "";
+	return std::string(demangled);
+}
+
+template <typename T>
+struct Reflector {
+	static std::string GetClassName() {
+		return GetBasicClassName<T>();
+	}
+};
+
+template <>
+struct Reflector<std::string> {
+	static std::string GetClassName() {
+		return "std::string";
+	}
+};
+
+template <typename K, typename V>
+struct Reflector<std::map<K, V>> {
+	static std::string GetClassName();
+};
+
+template <typename T>
+struct Reflector<std::vector<T>> {
+	static std::string GetClassName();
+};
+
+template <typename T>
+std::string Reflector<std::vector<T>>::GetClassName() {
+	return "std::vector<" + Reflector<T>::GetClassName() + ">";
+}
+
+template <typename K, typename V>
+std::string Reflector<std::map<K, V>>::GetClassName() {
+	return "std::map<" + Reflector<K>::GetClassName() + ", " + Reflector<V>::GetClassName() + ">";
+}
+
+}  // namespace sp

include/sp/common/Templates.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cstdint>
+#include <string>
 
 namespace sp {
 
@@ -50,4 +51,48 @@ void TupleForEach(TFunc&& func, TTuple&& tuple) {
 	details::TupleForEachHelper<TupleSize>::Exec(std::forward<TTuple>(tuple), std::forward<TFunc>(func));
 }
 
+
+
+
+
+
+
+
+
+namespace details {
+
+template <typename T, typename U = void>
+struct is_mappish_impl : std::false_type {};
+
+template <typename T>
+struct is_mappish_impl<T, std::void_t<typename T::key_type, typename T::mapped_type,
+							  decltype(std::declval<T&>()[std::declval<const typename T::key_type&>()])>> : std::true_type {};
+
+template <typename T, typename U = void>
+struct is_vectish_impl : std::false_type {};
+
+template <typename T>
+struct is_vectish_impl<T,
+	std::void_t<typename T::value_type, decltype(std::declval<T&>()[std::declval<const typename T::value_type&>()])>>
+	: std::true_type {};
+
+template <typename T, typename U = void>
+struct is_pairish_impl : std::false_type {};
+
+template <typename T>
+struct is_pairish_impl<T,
+	std::void_t<typename T::first_type, decltype(std::declval<T&>()[std::declval<const typename T::first_type&>()])>>
+	: std::true_type {};
+
+template <typename T>
+using is_general_t = std::integral_constant<bool,
+	(std::is_same_v<T, std::string> || (!std::is_same_v<T, char> && !std::is_same_v<T, unsigned char> && !std::is_arithmetic_v<T> &&
+										   !is_pairish_impl<T>::value && !is_mappish_impl<T>::value && !is_vectish_impl<T>::value))>;
+
+template <typename T>
+using is_primitive =
+	std::integral_constant<bool, std::is_same_v<T, char> || std::is_same_v<T, unsigned char> || std::is_arithmetic_v<T>>;
+
+}  // namespace details
+
 }  // namespace sp

include/sp/common/VarInt.h

@@ -7,6 +7,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <sp/protocol/MessagePrinter.h>
 
 namespace sp {
 
@@ -57,4 +58,9 @@ class VarInt {
 	friend DataBuffer& operator>>(DataBuffer& in, VarInt& var);
 };
 
+template<>
+inline std::string PrintData(const VarInt& a_VarInt) {
+	return PrintData(a_VarInt.GetValue());
+}
+
 }  // namespace sp

include/sp/default/DefaultPacket.h

@@ -11,8 +11,9 @@ using PacketMessage = Message<
 	option::ReadOperations,										// add read() operation
 	option::WriteOperations,									// add write() operation
 	option::WriteId,											// write id before data
-	option::Handler<PacketHandler>			// add dispatch() operation
->;
+	option::Handler<PacketHandler>,								// add dispatch() operation
+	option::DebugPrint											// add ToString() operator
+	>;
 
 #define PacketConstructor(packetName)                                                                                                 \
 	packetName##Packet() {}                                                                                                           \
@@ -23,7 +24,8 @@ using PacketMessage = Message<
 
 #define DeclarePacket(packetName)                                                                                                     \
 	class packetName##Packet : public sp::MessageBase<sp::PacketMessage, sp::option::StaticNumIdImpl<packetName>,                     \
-								   sp::option::DispatchImpl<packetName##Packet>, sp::option::FieldsImpl<packetName##Fields>>
+								   sp::option::DispatchImpl<packetName##Packet>, sp::option::FieldsImpl<packetName##Fields>>,         \
+							   sp::option::ToStringImpl<packetName##Packet>
 
 
 

include/sp/io/IOInterfaceImpl.inl

@@ -48,11 +48,12 @@ Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::Stream(
 template <typename IOTag, typename MessageDispatcher, typename MessageFactory, typename... TOptions>
 void Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::SendMessage(const MessageBase& a_Message) {
 	DataBuffer data = a_Message.Write();
-	DataBuffer encapsulated = std::apply([&data](const auto&... a_Options) {
-		return Encapsulate(data, a_Options...);
+	TupleForEach([&data](const auto&... a_Options) {
+		data = Encapsulate(data, a_Options...);
 	}, m_Options);
 	DataBuffer finalData;
-	finalData << VarInt{encapsulated.GetSize()} << encapsulated;
+	finalData.Reserve(data.GetSize() + sizeof(VarInt::MAX_VALUE));
+	finalData << VarInt{data.GetSize()} << data;
 	m_Interface.Write(finalData);
 }
 
@@ -93,8 +94,8 @@ void Stream<IOTag, MessageDispatcher, MessageFactory, TOptions...>::RecieveMessa
 		DataBuffer buffer;
 		buffer = m_Interface.Read(lenghtValue);
 
-		buffer = std::apply([&buffer, lenghtValue](const auto&... a_Options) {
-			return Decapsulate(buffer, a_Options...);
+		TupleForEach([&buffer, lenghtValue](const auto&... a_Options) {
+			buffer = Decapsulate(buffer, a_Options...);
 		}, m_Options);
 
 		VarInt packetType;

include/sp/protocol/Field.h

@@ -70,29 +70,32 @@ class BitField {
  * \tparam ValueType the type of the value to store
  * \tparam IAlignment 0 means no alignment
  */
-template <typename ValueType, int IAlignment>
+template <typename ValueType, std::size_t IAlignment>
 class Field {
   public:
+	using StorageType = ValueType;
+	static constexpr std::size_t AlignmentValue = IAlignment;
+
 	// Provide an access to the stored value
-	ValueType& GetValue() {
+	StorageType& GetValue() {
 		return m_Value;
 	}
 
-	const ValueType& GetValue() const {
+	const StorageType& GetValue() const {
 		return m_Value;
 	}
 
-	Field& operator=(const ValueType& value) {
+	Field& operator=(const StorageType& value) {
 		m_Value = value;
 		return *this;
 	}
 
-	constexpr int GetAlignment() const {
+	constexpr std::size_t GetAlignment() const {
 		return IAlignment;
 	}
 
   private:
-	ValueType m_Value;
+	StorageType m_Value;
 };
 
 namespace details {

include/sp/protocol/MessageBase.h

@@ -14,3 +14,5 @@ template <typename TBase, typename... TOptions>
 class MessageBase : public details::MessageImplBuilder<TBase, TOptions...>::Type {};
 
 }  // namespace sp
+
+#include <sp/protocol/message/MessagePrinterImpl.h>

include/sp/protocol/MessagePrinter.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <map>
+#include <sp/common/Templates.h>
+#include <string>
+#include <vector>
+
+namespace sp {
+
+template <typename T, std::enable_if_t<details::is_general_t<T>::value, bool> = true>
+inline std::string PrintData(const T& a_Data);
+
+template <typename T, std::enable_if_t<details::is_primitive<T>::value, bool> = true>
+inline std::string PrintData(T a_Data) {
+	return std::to_string(a_Data);
+}
+
+template <>
+inline std::string PrintData(const std::string& a_Data) {
+	return "\"" + a_Data + "\"";
+}
+
+template <typename K, typename V>
+std::string PrintData(const std::pair<K, V>& a_Data);
+
+template <typename K, typename V>
+std::string PrintData(const std::map<K, V>& a_Data);
+
+template <typename T>
+std::string PrintData(const std::vector<T>& a_Data);
+
+template <typename K, typename V>
+std::string PrintData(const std::pair<K, V>& a_Data) {
+	return "{" + PrintData(a_Data.first) + " => " + PrintData(a_Data.second) + "}";
+}
+
+template <typename K, typename V>
+std::string PrintData(const std::map<K, V>& a_Data) {
+	std::string result = "{";
+	for (const auto& pair : a_Data) {
+		result += PrintData(pair) + ", ";
+	}
+	return result.substr(0, result.size() - 2) + "}";
+}
+
+template <typename T>
+std::string PrintData(const std::vector<T>& a_Data) {
+	std::string result = "{";
+	for (const T& value : a_Data) {
+		result += PrintData(value) + ", ";
+	}
+	return result.substr(0, result.size() - 2) + "}";
+}
+
+}  // namespace sp

include/sp/protocol/message/ArrayFillerImpl.h

@@ -31,7 +31,7 @@ struct ArrayFiller<TBase, TMessage, TMessages...> {
 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>(); });
+		array.emplace_back([]() -> std::unique_ptr<TBase> { return std::make_unique<TMessage>(); });
 	}
 };
 

include/sp/protocol/message/MessageImplBuilder.h

@@ -37,8 +37,12 @@ struct MessageImplBuilder {
 	static const bool HasValidImpl = InterfaceOptions::HasValid && ImplOptions::HasFieldsImpl;
 	using Base6 = typename MessageImplProcessValidFields<Base5, HasValidImpl>::Type;
 
+	// Provide ToStringImpl() if possible
+	static const bool HasToStringImpl = InterfaceOptions::HasToString;
+	using Base7 = typename MessageImplProcessToString<Base6, ImplOptions, HasToStringImpl>::Type;
+
 	// The last BaseN must be taken as final type.
-	using Type = Base6;
+	using Type = Base7;
 };
 
 }  // namespace details

include/sp/protocol/message/MessageImplOptions.h

@@ -4,7 +4,7 @@ namespace sp {
 namespace option {
 
 // Provide static numeric ID, to facilitate implementation of GetIdImpl()
-template <std::intmax_t TId>
+template <std::uintmax_t TId>
 struct StaticNumIdImpl {};
 
 // Facilitate implementation of DispatchImpl()
@@ -16,6 +16,11 @@ struct DispatchImpl {};
 template <typename TFields>
 struct FieldsImpl {};
 
+// Print fields of the message, facilitate implementation of
+// ToStringImpl()
+template <typename TActual>
+struct ToStringImpl {};
+
 }  // namespace option
 
 
@@ -39,10 +44,10 @@ struct MessageImplParsedOptions<> {
 
 
 
-template <std::intmax_t TId, typename... TOptions>
+template <std::uintmax_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;
+	static const std::uintmax_t MsgId = TId;
 };
 
 template <typename TActual, typename... TOptions>

include/sp/protocol/message/MessageImplProcess.h

@@ -4,6 +4,20 @@ namespace sp {
 namespace details {
 
 
+// ToString impl
+template <typename TBase, typename ParsedImplOptions, bool TImplement>
+struct MessageImplProcessToString;
+
+template <typename TBase, typename ParsedImplOptions>
+struct MessageImplProcessToString<TBase, ParsedImplOptions, true> {
+	using Type = MessageImplToStringBase<TBase, typename ParsedImplOptions::ActualMessage>;
+};
+
+template <typename TBase, typename ParsedImplOptions>
+struct MessageImplProcessToString<TBase, ParsedImplOptions, false> {
+	using Type = TBase;
+};
+
 
 // id impl
 template <typename TBase, typename ParsedImplOptions, bool TImplement>

include/sp/protocol/message/MessageInterfaceBuilder.h

@@ -33,8 +33,11 @@ struct MessageInterfaceBuilder {
 	// add write id functionality if write id and write was provided
 	using Base7 = typename MessageInterfaceProcessWriteId<Base6, ParsedOptions::HasWriteId && ParsedOptions::HasWriteOperations>::Type;
 
-	// The last Base7 must be taken as final type.
-	using Type = Base7;
+	// add ToString() if HasToString was provided
+	using Base8 = typename MessageInterfaceProcessToString<Base7, ParsedOptions::HasToString>::Type;
+
+	// The last Base8 must be taken as final type.
+	using Type = Base8;
 };
 
 }  // namespace details

include/sp/protocol/message/MessageInterfaceProcess.h

@@ -101,5 +101,19 @@ struct MessageInterfaceProcessWriteId<TBase, false> {
 	using Type = TBase;
 };
 
+// Build to string 
+template <typename TBase, bool THasToString>
+struct MessageInterfaceProcessToString;
+
+template <typename TBase>
+struct MessageInterfaceProcessToString<TBase, true> {
+	using Type = MessageInterfaceToStringBase<TBase>;
+};
+
+template <typename TBase>
+struct MessageInterfaceProcessToString<TBase, false> {
+	using Type = TBase;
+};
+
 }  // namespace details
 }  // namespace sp

include/sp/protocol/message/MessageInterfacesImpl.h

@@ -129,5 +129,17 @@ class MessageInterfaceWriteIdBase : public TBase {
 	}
 };
 
+// Debug print functionality chunk
+template <typename TBase>
+class MessageInterfaceToStringBase : public TBase {
+  public:
+	std::string ToString() const {
+		return ToStringImpl();
+	}
+
+  protected:
+	virtual std::string ToStringImpl() const = 0;
+};
+
 }  // namespace details
 }  // namespace sp

include/sp/protocol/message/MessageInterfacesOptions.h

@@ -16,6 +16,7 @@ struct MessageInterfaceParsedOptions<> {
 	static const bool HasWriteId = false;
 	static const bool HasHandler = false;
 	static const bool HasValid = false;
+	static const bool HasToString = false;
 };
 
 
@@ -59,5 +60,10 @@ struct MessageInterfaceParsedOptions<option::ValidCheckInterface, TOptions...> :
 	static const bool HasValid = true;
 };
 
+template <typename... TOptions>
+struct MessageInterfaceParsedOptions<option::DebugPrint, TOptions...> : public MessageInterfaceParsedOptions<TOptions...> {
+	static const bool HasToString = true;
+};
+
 }  // namespace details
 }  // namespace sp

include/sp/protocol/message/MessageOptions.h

@@ -24,6 +24,9 @@ struct LittleEndian {};
 // Include validity check in public interface
 struct ValidCheckInterface {};
 
+// Add a ToString() method containing fields
+struct DebugPrint {};
+
 // Define handler class
 template <typename T>
 struct Handler {

include/sp/protocol/message/MessagePrinterImpl.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <sp/common/Reflection.h>
+#include <sp/common/Templates.h>
+#include <sp/protocol/MessagePrinter.h>
+
+namespace sp {
+namespace details {
+
+template <typename... TOptions>
+struct IdPrinter {};
+
+template <>
+struct IdPrinter<> {
+	static std::string PrintMessageId() {
+		return "";
+	}
+};
+
+template <typename TOption, typename... TOptions>
+struct IdPrinter<TOption, TOptions...> {
+	static std::string PrintMessageId() {
+		return IdPrinter<TOptions...>::PrintMessageId();
+	}
+};
+
+template <typename... TOptions, std::uintmax_t TId>
+struct IdPrinter<option::StaticNumIdImpl<TId>, TOptions...> {
+	static std::string PrintMessageId() {
+		return "(Id: " + std::to_string(TId) + ")";
+	}
+};
+
+template <typename... TFields>
+std::string PrintFields(const std::tuple<TFields...>& a_Fields);
+
+template <typename TField, unsigned int IAlignment>
+struct FieldPrinter {
+	static std::string PrintField(const sp::Field<TField, IAlignment>& a_Field) {
+		return Reflector<TField>::GetClassName() + "=" + PrintData(a_Field.GetValue());
+	}
+};
+
+template <unsigned int IAlignment, typename TContainer, typename... TFields>
+struct FieldPrinter<BitField<TContainer, TFields...>, IAlignment> {
+	static std::string PrintField(const Field<BitField<TContainer, TFields...>, IAlignment>& a_Field) {
+		return "BitField<" + Reflector<TContainer>::GetClassName() + ">[" + PrintFields(a_Field.GetValue().GetFields()) + "]";
+	}
+};
+
+template <typename... TFields>
+std::string PrintFields(const std::tuple<TFields...>& a_Fields) {
+	std::string concat;
+	TupleForEach(
+		[&concat](const auto& a_Field) {
+			using TField = typename std::decay<decltype(a_Field)>::type;
+			constexpr std::size_t alignment = TField::AlignmentValue;
+			concat += FieldPrinter<typename TField::StorageType, alignment>::PrintField(a_Field) + ", ";
+		},
+		a_Fields);
+	return concat.substr(0, concat.size() - 2);
+}
+
+template <typename TBase, typename... TOptions>
+std::string PrintMessage(const MessageBase<TBase, TOptions...>& a_Message) {
+	return sp::GetBasicClassName(a_Message) + sp::details::IdPrinter<TOptions...>::PrintMessageId() + "[" +
+		   sp::details::PrintFields(a_Message.GetFields()) + "]";
+}
+
+}  // namespace details
+}  // namespace sp

include/sp/protocol/message/MessagesImpl.h

@@ -1,8 +1,24 @@
 #pragma once
 
 namespace sp {
+
+template <typename TBase, typename... TOptions>
+class MessageBase;
+
 namespace details {
 
+template <typename TBase, typename... TOptions>
+std::string PrintMessage(const MessageBase<TBase, TOptions...>& a_Message);
+
+// ID information chunk
+template <typename TBase, typename TActual>
+class MessageImplToStringBase : public TBase {
+  protected:
+	virtual std::string ToStringImpl() const override {
+		return PrintMessage(static_cast<const TActual&>(*this));
+	}
+};
+
 
 
 // ID information chunk
@@ -18,6 +34,8 @@ class MessageImplStaticNumIdBase : public TBase {
 	}
 };
 
+
+
 // Dispatch implementation chunk
 template <typename TBase, typename TActual>
 class MessageImplDispatchBase : public TBase {
@@ -81,7 +99,7 @@ class MessageImplFieldsReadBase : public TBase {
 	}
 
 	// reading field in bitfield
-	template <typename TFieldType, typename TField, int IAlignment>
+	template <typename TFieldType, typename TField, std::size_t 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
@@ -118,7 +136,7 @@ class MessageImplFieldsWriteBase : public TBase {
 	}
 
 	// writing field in bitfield
-	template <typename TFieldType, typename TField, int IAlignment>
+	template <typename TFieldType, typename TField, std::size_t IAlignment>
 	void WriteField(const Field<TField, IAlignment>& field, TFieldType& data, std::size_t offset) const {
 		static constexpr std::size_t TotalBitCount = sizeof(TFieldType) * 8;
 		// we suppose that the first element is at the highest bits

src/sp/common/VarInt.cpp

@@ -1,7 +1,7 @@
 #include <sp/common/VarInt.h>
 
-#include <stdexcept>
 #include <sp/common/DataBuffer.h>
+#include <stdexcept>
 
 namespace sp {
 

test/test_packets.cpp

@@ -8,7 +8,8 @@
 
 class KeepAliveHandler : public sp::PacketHandler {
 	void Handle(const KeepAlivePacket& packet) {
-		std::cout << "KeepAlive handled !\n";
+		std::cout << "KeepAlive handled !!\n";
+		std::cout << packet.ToString() << std::endl;
 	}
 
 	void Handle(const DisconnectPacket& packet) {
@@ -21,12 +22,14 @@ class KeepAliveHandler : public sp::PacketHandler {
 };
 
 int main() {
-	auto upgradeTower = std::make_unique<UpgradeTowerPacket>(std::make_tuple(666, 9));
+	auto upgradeTower = std::make_unique<UpgradeTowerPacket>(std::make_tuple(666, 9), 789);
+	auto keepAlive = std::make_unique<KeepAlivePacket>(6969);
 
 	sp::PacketMessage* msg = upgradeTower.get();
 
 	auto handler = std::make_shared<KeepAliveHandler>();
 	msg->Dispatch(*handler);
+	keepAlive->Dispatch(*handler);
 
 	sp::DataBuffer buffer = msg->Write();
 
@@ -36,7 +39,7 @@ int main() {
 	auto upgradeTower2 = std::make_unique<UpgradeTowerPacket>();
 	upgradeTower2->Read(buffer);
 
-	std::cout << "Test : " << (unsigned)upgradeTower2->GetTowerId() << "\n";
+	std::cout << "Test : " << msg->ToString() << "\n";
 
 	sp::PacketFactory factory;
 	auto packet = factory.CreateMessage(msgId);