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

allow message serialization through DataBuffer

Browse Source
This commit is contained in:
Simon Pribylski
2025-07-31 15:01:37 +02:00
parent a1a4176801
commit 01aed44408
3 changed files with 250 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

198
include/sp/common/DataBuffer.h
View File

@@ -84,97 +84,6 @@ class DataBuffer {
*/
DataBuffer& operator<<(const DataBuffer& data);
/**
* \brief Append a pointer to the buffer
* \param data The data to append
*/
template <typename T>
DataBuffer& operator<<(const std::shared_ptr<T>& data) {
return *this << *data;
}
/**
* \brief Append a pointer to the buffer
* \param data The data to append
*/
template <typename T>
DataBuffer& operator<<(const std::unique_ptr<T>& data) {
return *this << *data;
}
/**
* \brief Append a vector to the buffer by first writing the size
* \param data The vector to append
*/
template <typename T>
DataBuffer& operator<<(const std::vector<T>& data) {
*this << VarInt{data.size()};
for (const auto& element : data) {
*this << element;
}
return *this;
}
/**
* \brief Append a list to the buffer by first writing the size
* \param data The list to append
*/
template <typename T>
DataBuffer& operator<<(const std::list<T>& data) {
*this << VarInt{data.size()};
for (const auto& element : data) {
*this << element;
}
return *this;
}
/**
* \brief Append a map to the buffer by first writing the size
* \param data The map to append
*/
template <typename K, typename V>
DataBuffer& operator<<(const std::map<K, V>& data) {
*this << VarInt{data.size()};
for (const auto& [key, value] : data) {
*this << key << value;
}
return *this;
}
/**
* \brief Append a map to the buffer by first writing the size
* \param data The map to append
*/
template <typename K, typename V>
DataBuffer& operator<<(const std::unordered_map<K, V>& data) {
*this << VarInt{data.size()};
for (const auto& [key, value] : data) {
*this << key << value;
}
return *this;
}
/**
* \brief Append a pair to the buffer
* \param data The pair to append
*/
template <typename K, typename V>
DataBuffer& operator<<(const std::pair<K, V>& data) {
return *this << data.first << data.second;
}
/**
* \brief Append an array to the buffer by first writing the size
* \param data The buffer to append
*/
template <typename T, std::size_t Size>
DataBuffer& operator<<(const std::array<T, Size>& data) {
for (const auto& element : data) {
*this << element;
}
return *this;
}
/**
* \brief Read data into a_Data
* \warning No endian checks
@@ -209,111 +118,6 @@ class DataBuffer {
*/
DataBuffer& operator>>(std::string& str);
/**
* \brief Read a pointer
*/
template <typename T>
DataBuffer& operator>>(std::shared_ptr<T>& data) {
data = std::make_shared<T>();
return *this >> *data;
}
/**
* \brief Read a pointer
*/
template <typename T>
DataBuffer& operator>>(std::unique_ptr<T>& data) {
data = std::make_unique<T>();
return *this >> *data;
}
/**
* \brief Read a vector (size + data) from the buffer
* \pre The vector is assumed to be empty
*/
template <typename T>
DataBuffer& operator>>(std::vector<T>& data) {
VarInt arraySize;
*this >> arraySize;
for (std::size_t i = 0; i < arraySize.GetValue(); i++) {
T newElement;
*this >> newElement;
data.push_back(newElement);
}
return *this;
}
/**
* \brief Read a list (size + data) from the buffer
* \pre The list is assumed to be empty
*/
template <typename T>
DataBuffer& operator>>(std::list<T>& data) {
VarInt arraySize;
*this >> arraySize;
for (std::size_t i = 0; i < arraySize.GetValue(); i++) {
T newElement;
*this >> newElement;
data.push_back(newElement);
}
return *this;
}
/**
* \brief Read a map (size + data) from the buffer
* \pre The map is assumed to be empty
*/
template <typename K, typename V>
DataBuffer& operator>>(std::map<K, V>& data) {
VarInt mapSize;
*this >> mapSize;
for (std::size_t i = 0; i < mapSize.GetValue(); i++) {
K newKey;
V newValue;
*this >> newKey >> newValue;
data.emplace(newKey, newValue);
}
return *this;
}
/**
* \brief Read a map (size + data) from the buffer
* \pre The map is assumed to be empty
*/
template <typename K, typename V>
DataBuffer& operator>>(std::unordered_map<K, V>& data) {
VarInt mapSize;
*this >> mapSize;
for (std::size_t i = 0; i < mapSize.GetValue(); i++) {
K newKey;
V newValue;
*this >> newKey >> newValue;
data.emplace(newKey, newValue);
}
return *this;
}
/**
* \brief Read a pair
*/
template <typename K, typename V>
DataBuffer& operator>>(std::pair<K, V>& data) {
return *this >> data.first >> data.second;
}
/**
* \brief Read an array from the buffer
*/
template <std::size_t Size, typename T>
DataBuffer& operator>>(std::array<T, Size>& data) {
for (std::size_t i = 0; i < Size; i++) {
T newElement;
*this >> newElement;
data[i] = newElement;
}
return *this;
}
/**
* \brief Write some data to the buffer
* \param buffer The buffer to write
@@ -459,3 +263,5 @@ class DataBuffer {
std::ostream& operator<<(std::ostream& os, const DataBuffer& buffer);
} // namespace sp
#include "DataBuffer.inl"

201
include/sp/common/DataBuffer.inl Normal file
View File

@@ -0,0 +1,201 @@
#pragma once
namespace sp {
/**
* \brief Append a pointer to the buffer
* \param data The data to append
*/
template <typename T, typename = typename std::enable_if_t<!std::is_abstract_v<T>>>
DataBuffer& operator<<(DataBuffer& buffer, const std::shared_ptr<T>& data) {
return buffer << *data;
}
/**
* \brief Append a pointer to the buffer
* \param data The data to append
*/
template <typename T, typename = typename std::enable_if_t<!std::is_abstract_v<T>>>
DataBuffer& operator<<(DataBuffer& buffer, const std::unique_ptr<T>& data) {
return buffer << *data;
}
/**
* \brief Append a vector to the buffer by first writing the size
* \param data The vector to append
*/
template <typename T>
DataBuffer& operator<<(DataBuffer& buffer, const std::vector<T>& data) {
buffer << VarInt{data.size()};
for (const auto& element : data) {
buffer << element;
}
return buffer;
}
/**
* \brief Append a list to the buffer by first writing the size
* \param data The list to append
*/
template <typename T>
DataBuffer& operator<<(DataBuffer& buffer, const std::list<T>& data) {
buffer << VarInt{data.size()};
for (const auto& element : data) {
buffer << element;
}
return buffer;
}
/**
* \brief Append a map to the buffer by first writing the size
* \param data The map to append
*/
template <typename K, typename V>
DataBuffer& operator<<(DataBuffer& buffer, const std::map<K, V>& data) {
buffer << VarInt{data.size()};
for (const auto& [key, value] : data) {
buffer << key << value;
}
return buffer;
}
/**
* \brief Append a map to the buffer by first writing the size
* \param data The map to append
*/
template <typename K, typename V>
DataBuffer& operator<<(DataBuffer& buffer, const std::unordered_map<K, V>& data) {
buffer << VarInt{data.size()};
for (const auto& [key, value] : data) {
buffer << key << value;
}
return buffer;
}
/**
* \brief Append a pair to the buffer
* \param data The pair to append
*/
template <typename K, typename V>
DataBuffer& operator<<(DataBuffer& buffer, const std::pair<K, V>& data) {
return buffer << data.first << data.second;
}
/**
* \brief Append an array to the buffer by first writing the size
* \param data The buffer to append
*/
template <typename T, std::size_t Size>
DataBuffer& operator<<(DataBuffer& buffer, const std::array<T, Size>& data) {
for (const auto& element : data) {
buffer << element;
}
return buffer;
}
/**
* \brief Read a pointer
*/
template <typename T, typename = typename std::enable_if_t<!std::is_abstract_v<T>>>
DataBuffer& operator>>(DataBuffer& buffer, std::shared_ptr<T>& data) {
data = std::make_shared<T>();
return buffer >> *data;
}
/**
* \brief Read a pointer
*/
template <typename T, typename = typename std::enable_if_t<!std::is_abstract_v<T>>>
DataBuffer& operator>>(DataBuffer& buffer, std::unique_ptr<T>& data) {
data = std::make_unique<T>();
return buffer >> *data;
}
/**
* \brief Read a vector (size + data) from the buffer
* \pre The vector is assumed to be empty
*/
template <typename T>
DataBuffer& operator>>(DataBuffer& buffer, std::vector<T>& data) {
VarInt arraySize;
buffer >> arraySize;
for (std::size_t i = 0; i < arraySize.GetValue(); i++) {
T newElement;
buffer >> newElement;
data.push_back(newElement);
}
return buffer;
}
/**
* \brief Read a list (size + data) from the buffer
* \pre The list is assumed to be empty
*/
template <typename T>
DataBuffer& operator>>(DataBuffer& buffer, std::list<T>& data) {
VarInt arraySize;
buffer >> arraySize;
for (std::size_t i = 0; i < arraySize.GetValue(); i++) {
T newElement;
buffer >> newElement;
data.push_back(newElement);
}
return buffer;
}
/**
* \brief Read a map (size + data) from the buffer
* \pre The map is assumed to be empty
*/
template <typename K, typename V>
DataBuffer& operator>>(DataBuffer& buffer, std::map<K, V>& data) {
VarInt mapSize;
buffer >> mapSize;
for (std::size_t i = 0; i < mapSize.GetValue(); i++) {
K newKey;
V newValue;
buffer >> newKey >> newValue;
data.emplace(newKey, newValue);
}
return buffer;
}
/**
* \brief Read a map (size + data) from the buffer
* \pre The map is assumed to be empty
*/
template <typename K, typename V>
DataBuffer& operator>>(DataBuffer& buffer, std::unordered_map<K, V>& data) {
VarInt mapSize;
buffer >> mapSize;
for (std::size_t i = 0; i < mapSize.GetValue(); i++) {
K newKey;
V newValue;
buffer >> newKey >> newValue;
data.emplace(newKey, newValue);
}
return buffer;
}
/**
* \brief Read a pair
*/
template <typename K, typename V>
DataBuffer& operator>>(DataBuffer& buffer, std::pair<K, V>& data) {
return buffer >> data.first >> data.second;
}
/**
* \brief Read an array from the buffer
*/
template <std::size_t Size, typename T>
DataBuffer& operator>>(DataBuffer& buffer, std::array<T, Size>& data) {
for (std::size_t i = 0; i < Size; i++) {
T newElement;
buffer >> newElement;
data[i] = newElement;
}
return buffer;
}
} // namespace sp

47
include/sp/io/MessageSerialize.h Normal file
View File

@@ -0,0 +1,47 @@
#pragma once
#include <sp/protocol/MessageFactory.h>
namespace sp {
template <typename TMessageID, typename THandler>
DataBuffer& operator<<(DataBuffer& a_Buffer, const std::unique_ptr<MessageBase<TMessageID, THandler>>& a_Message) {
return a_Buffer << VarInt{static_cast<std::uint64_t>(a_Message->GetId())} << a_Message->Write();
}
template <typename TMessageID, typename THandler>
DataBuffer& operator<<(DataBuffer& a_Buffer, const std::shared_ptr<MessageBase<TMessageID, THandler>>& a_Message) {
return a_Buffer << VarInt{static_cast<std::uint64_t>(a_Message->GetId())} << a_Message->Write();
}
template <typename TMessageID, typename THandler, typename TTMessages>
DataBuffer& operator>>(DataBuffer& a_Buffer, std::unique_ptr<MessageBase<TMessageID, THandler>>& a_Message) {
using TBase = MessageBase<TMessageID, THandler>;
using MsgId = typename TBase::MessageIdType;
static MessageFactory<TBase, TTMessages> factory;
VarInt msgId;
a_Buffer >> msgId;
a_Message = factory.CreateMessage(MsgId(msgId.GetValue()));
a_Message->Read(a_Buffer);
return a_Buffer;
}
template <typename TMessageID, typename THandler, typename TTMessages>
DataBuffer& operator>>(DataBuffer& a_Buffer, std::shared_ptr<MessageBase<TMessageID, THandler>>& a_Message) {
using TBase = MessageBase<TMessageID, THandler>;
using MsgId = typename TBase::MessageIdType;
static MessageFactory<TBase, TTMessages> factory;
VarInt msgId;
a_Buffer >> msgId;
a_Message = std::shared_ptr<TBase>(factory.CreateMessage(MsgId(msgId.GetValue())).release());
a_Message->Read(a_Buffer);
return a_Buffer;
}
} // namespace sp