add operator<< for packets (#14)

Reviewed-on: #14
Co-authored-by: Persson-dev <sim16.prib@gmail.com>
Co-committed-by: Persson-dev <sim16.prib@gmail.com>

include/sp/protocol/Field.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <sp/common/DataBuffer.h>
 #include <sp/common/Templates.h>
 
 namespace sp {
@@ -98,6 +97,19 @@ class Field {
 	StorageType m_Value;
 };
 
+template <typename T>
+class PrintableField {
+  public:
+	PrintableField(const T& a_Value) : m_Value(a_Value) {}
+
+	const T& GetValue() const {
+		return m_Value;
+	}
+
+  private:
+	const T& m_Value;
+};
+
 namespace details {
 
 template <typename... TFields>

include/sp/protocol/MessagePrinter.h

@@ -1,55 +1,61 @@
 #pragma once
 
 #include <map>
-#include <sp/common/Templates.h>
+#include <ostream>
+#include <sp/protocol/Field.h>
+#include <sp/protocol/message/OstreamFieldIterator.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);
+std::ostream& operator<<(std::ostream& a_Stream, const PrintableField<T>& a_Field) {
+	return a_Stream << std::to_string(a_Field.GetValue());
 }
 
-template <>
-inline std::string PrintData(const std::string& a_Data) {
-	return "\"" + a_Data + "\"";
+inline std::ostream& operator<<(std::ostream& a_Stream, const PrintableField<long unsigned int>& a_Field) {
+	return a_Stream << a_Field.GetValue();
 }
 
-template <typename K, typename V>
-std::string PrintData(const std::pair<K, V>& a_Data);
+inline std::ostream& operator<<(std::ostream& a_Stream, const PrintableField<std::string>& a_Field) {
+	return a_Stream << "\"" << a_Field.GetValue() << "\"";
+}
+
+
+
+
 
 template <typename K, typename V>
-std::string PrintData(const std::map<K, V>& a_Data);
+std::ostream& operator<<(std::ostream& a_Stream, const PrintableField<std::pair<K, V>>& a_Data);
+
+template <typename K, typename V>
+std::ostream& operator<<(std::ostream& a_Stream, const PrintableField<std::map<K, V>>& a_Data);
 
 template <typename T>
-std::string PrintData(const std::vector<T>& a_Data);
+std::ostream& operator<<(std::ostream& a_Stream, const PrintableField<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) + "}";
+std::ostream& operator<<(std::ostream& a_Stream, const PrintableField<std::pair<K, V>>& a_Data) {
+	return a_Stream << PrintableField<K>(a_Data.GetValue().first) << " => " << PrintableField<V>(a_Data.GetValue().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) + "}";
+std::ostream& operator<<(std::ostream& a_Stream, const PrintableField<std::map<K, V>>& a_Data) {
+	a_Stream << "{";
+	std::copy(a_Data.GetValue().begin(), a_Data.GetValue().end(), OstreamFieldIterator<std::pair<K, V>>(std::cout, ", "));
+	return a_Stream << "}";
 }
 
 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) + "}";
+std::ostream& operator<<(std::ostream& a_Stream, const PrintableField<std::vector<T>>& a_Data) {
+	a_Stream << "{";
+	std::copy(a_Data.GetValue().begin(), a_Data.GetValue().end(), OstreamFieldIterator<T>(std::cout, ", "));
+	return a_Stream << "}";
 }
 
-}  // namespace sp
+}  // namespace sp

include/sp/protocol/message/MessageInterfacesImpl.h

@@ -133,12 +133,12 @@ class MessageInterfaceWriteIdBase : public TBase {
 template <typename TBase>
 class MessageInterfaceToStringBase : public TBase {
   public:
-	std::string ToString() const {
-		return ToStringImpl();
+	friend std::ostream& operator<<(std::ostream& a_Stream, const MessageInterfaceToStringBase& a_Message) {
+		return a_Message.OpOutImpl(a_Stream);
 	}
 
   protected:
-	virtual std::string ToStringImpl() const = 0;
+	virtual std::ostream& OpOutImpl(std::ostream& a_Stream) const = 0;
 };
 
 }  // namespace details

include/sp/protocol/message/MessagePrinterImpl.h

@@ -31,41 +31,49 @@ struct IdPrinter<option::StaticNumIdImpl<TId>, TOptions...> {
 	}
 };
 
+}  // namespace details
+
 template <typename... TFields>
-std::string PrintFields(const std::tuple<TFields...>& a_Fields);
+std::ostream& operator<<(std::ostream& a_Stream, 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());
+	static std::ostream& PrintField(std::ostream& a_Stream, const sp::Field<TField, IAlignment>& a_Field) {
+		return a_Stream << sp::Reflector<TField>::GetClassName() << "=" << PrintableField<TField>(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()) + "]";
+struct FieldPrinter<sp::BitField<TContainer, TFields...>, IAlignment> {
+	static std::ostream& PrintField(
+		std::ostream& a_Stream, const sp::Field<sp::BitField<TContainer, TFields...>, IAlignment>& a_Field) {
+		a_Stream << "BitField<" << sp::Reflector<TContainer>::GetClassName() << ">[";
+		a_Stream << a_Field.GetValue().GetFields() << "]";
+		return a_Stream;
 	}
 };
 
 template <typename... TFields>
-std::string PrintFields(const std::tuple<TFields...>& a_Fields) {
-	std::string concat;
+std::ostream& operator<<(std::ostream& a_Stream, const std::tuple<TFields...>& a_Fields) {
+	bool first = true;
 	TupleForEach(
-		[&concat](const auto& a_Field) {
+		[&a_Stream, &first](const auto& a_Field) {
+			if (!first)
+				a_Stream << ", ";
 			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) + ", ";
+			FieldPrinter<typename TField::StorageType, alignment>::PrintField(a_Stream, a_Field);
+			first = false;
 		},
 		a_Fields);
-	return concat.substr(0, concat.size() - 2);
+	return a_Stream;
 }
 
 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()) + "]";
+std::ostream& operator<<(std::ostream& a_Stream, const sp::MessageBase<TBase, TOptions...>& a_Message) {
+	a_Stream << sp::GetBasicClassName(a_Message) << sp::details::IdPrinter<TOptions...>::PrintMessageId() << "["
+			 << a_Message.GetFields() << "]";
+	return a_Stream;
 }
 
-}  // namespace details
-}  // namespace sp
+}  // namespace sp

include/sp/protocol/message/MessagesImpl.h

@@ -14,8 +14,8 @@ std::string PrintMessage(const MessageBase<TBase, TOptions...>& a_Message);
 template <typename TBase, typename TActual>
 class MessageImplToStringBase : public TBase {
   protected:
-	virtual std::string ToStringImpl() const override {
-		return PrintMessage(static_cast<const TActual&>(*this));
+	virtual std::ostream& OpOutImpl(std::ostream& a_Stream) const override{
+		return a_Stream << static_cast<const TActual&>(*this);
 	}
 };
 

include/sp/protocol/message/OstreamFieldIterator.h

@@ -0,0 +1,56 @@
+// infix_iterator.h
+//
+// Lifted from Jerry Coffin's 's prefix_ostream_iterator
+#pragma once
+
+#include <ostream>
+#include <sp/protocol/Field.h>
+
+namespace sp {
+
+template <class T, class charT = char, class traits = std::char_traits<charT>>
+class OstreamFieldIterator {
+  private:
+	std::basic_ostream<charT, traits>* m_Os;
+	std::string m_Delimiter;
+	bool m_FirstElem;
+
+  public:
+	using iterator_category = std::output_iterator_tag;
+	using value_type = void;
+	using difference_type = void;
+	using pointer = void;
+	using reference = void;
+
+	using char_type = charT;
+	using traits_type = traits;
+	using ostream_type = std::basic_ostream<charT, traits>;
+
+	OstreamFieldIterator(ostream_type& a_Stream) : m_Os(&a_Stream), m_Delimiter(0), m_FirstElem(true) {}
+	OstreamFieldIterator(ostream_type& a_Stream, std::string&& a_Delimiter) :
+		m_Os(&a_Stream), m_Delimiter(std::move(a_Delimiter)), m_FirstElem(true) {}
+
+	auto& operator=(const T& item) {
+		// Here's the only real change from ostream_iterator:
+		// Normally, the '*m_Os << item;' would come before the 'if'.
+		if (!m_FirstElem && !m_Delimiter.empty())
+			*m_Os << m_Delimiter;
+		*m_Os << sp::PrintableField<T>(item);
+		m_FirstElem = false;
+		return *this;
+	}
+
+	auto& operator*() {
+		return *this;
+	}
+
+	auto& operator++() {
+		return *this;
+	}
+
+	auto& operator++(int) {
+		return *this;
+	}
+};
+
+}  // namespace sp