Persson-dev/Simple-Protocol-Lib
1
0
Fork 0
Code Issues 4 Pull Requests Actions Packages Projects Releases Wiki Activity

add operator<< for packets #14

Merged
Persson-dev merged 3 commits from operator into main 2025-03-13 15:20:38 +00:00
Conversation 0 Commits 3 Files Changed 11 +147 -60
11 changed files with 147 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
include/examples/UpgradeTowerPacket.h
View File

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

1
include/sp/common/Templates.h
View File

@@ -2,6 +2,7 @@
#include <cstdint>
#include <string>
#include <tuple>
namespace sp {

10
include/sp/common/VarInt.h
View File

@@ -7,7 +7,8 @@
#include <cstddef>
#include <cstdint>
#include <sp/protocol/MessagePrinter.h>
#include <ostream>
#include <sp/protocol/Field.h>
namespace sp {
@@ -56,11 +57,8 @@ class VarInt {
* \param var The variable integer to deserialize
*/
friend DataBuffer& operator>>(DataBuffer& in, VarInt& var);
friend std::ostream& operator<<(std::ostream& a_Stream, const PrintableField<VarInt>& a_VarInt);
};
template<>
inline std::string PrintData(const VarInt& a_VarInt) {
return PrintData(a_VarInt.GetValue());
}
} // namespace sp

14
include/sp/protocol/Field.h
View File

@@ -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>

60
include/sp/protocol/MessagePrinter.h
View File

@@ -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

6
include/sp/protocol/message/MessageInterfacesImpl.h
View File

@@ -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

38
include/sp/protocol/message/MessagePrinterImpl.h
View File

@@ -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

4
include/sp/protocol/message/MessagesImpl.h
View File

@@ -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);
}
};

56
include/sp/protocol/message/OstreamFieldIterator.h Normal file
View File

@@ -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

4
src/sp/common/VarInt.cpp
View File

@@ -49,4 +49,8 @@ DataBuffer& operator>>(DataBuffer& in, VarInt& var) {
return in;
}
std::ostream& operator<<(std::ostream& a_Stream, const PrintableField<VarInt>& a_VarInt) {
return a_Stream << a_VarInt.GetValue().GetValue();
}
} // namespace sp

7
test/test_packets.cpp
View File

@@ -9,7 +9,7 @@
class KeepAliveHandler : public sp::PacketHandler {
void Handle(const KeepAlivePacket& packet) {
std::cout << "KeepAlive handled !!\n";
std::cout << packet.ToString() << std::endl;
std::cout << packet << std::endl;
}
void Handle(const DisconnectPacket& packet) {
@@ -22,7 +22,8 @@ class KeepAliveHandler : public sp::PacketHandler {
};
int main() {
auto upgradeTower = std::make_unique<UpgradeTowerPacket>(std::make_tuple(666, 9), 789);
std::map<std::string, std::vector<int>> yes = {{"woa", {5, 8}}, {"insane", {6, 9}}};
auto upgradeTower = std::make_unique<UpgradeTowerPacket>(std::make_tuple(666, 9), 789, yes);
auto keepAlive = std::make_unique<KeepAlivePacket>(6969);
sp::PacketMessage* msg = upgradeTower.get();
@@ -39,7 +40,7 @@ int main() {
auto upgradeTower2 = std::make_unique<UpgradeTowerPacket>();
upgradeTower2->Read(buffer);
std::cout << "Test : " << msg->ToString() << "\n";
std::cout << "Test : " << *msg << "\n";
sp::PacketFactory factory;
auto packet = factory.CreateMessage(msgId);