455 lines
12 KiB
C++
455 lines
12 KiB
C++
#pragma once
|
|
|
|
#include <boost/pfr.hpp>
|
|
#include <sp/common/DataBuffer.h>
|
|
|
|
namespace sp {
|
|
|
|
template <typename T>
|
|
using is_default_serializable = std::bool_constant<(std::is_class_v<T> && std::is_aggregate_v<T>) || !std::is_class_v<T>>;
|
|
|
|
template <typename T>
|
|
static constexpr bool is_default_serializable_v = is_default_serializable<T>::value;
|
|
|
|
namespace details {
|
|
|
|
template <typename T>
|
|
void WriteRaw(DataBuffer& a_Buffer, T a_Data);
|
|
|
|
template <typename T>
|
|
void WriteFields(DataBuffer& a_Buffer, const T& a_Data);
|
|
|
|
template <typename T>
|
|
void WriteSharedPtr(DataBuffer& a_Buffer, const std::shared_ptr<T>& a_Data);
|
|
|
|
template <typename T>
|
|
void WriteUniquePtr(DataBuffer& a_Buffer, const std::unique_ptr<T>& a_Data);
|
|
|
|
template <typename T>
|
|
void WriteVector(DataBuffer& a_Buffer, const std::vector<T>& a_Data);
|
|
|
|
template <typename T>
|
|
void WriteList(DataBuffer& a_Buffer, const std::list<T>& a_Data);
|
|
|
|
template <typename K, typename V>
|
|
void WriteMap(DataBuffer& a_Buffer, const std::map<K, V>& a_Data);
|
|
|
|
template <typename K, typename V>
|
|
void WriteUnorderedMap(DataBuffer& a_Buffer, const std::unordered_map<K, V>& a_Data);
|
|
|
|
template <typename K, typename V>
|
|
void WritePair(DataBuffer& a_Buffer, const std::pair<K, V>& a_Data);
|
|
|
|
template <typename T, std::size_t S>
|
|
void WriteArray(DataBuffer& a_Buffer, const std::array<T, S>& a_Data);
|
|
|
|
|
|
|
|
template <typename T>
|
|
void ReadRaw(DataBuffer& a_Buffer, T& a_Data);
|
|
|
|
template <typename T>
|
|
void ReadFields(DataBuffer& a_Buffer, T& a_Data);
|
|
|
|
template <typename T>
|
|
void ReadSharedPtr(DataBuffer& a_Buffer, std::shared_ptr<T>& a_Data);
|
|
|
|
template <typename T>
|
|
void ReadUniquePtr(DataBuffer& a_Buffer, std::unique_ptr<T>& a_Data);
|
|
|
|
template <typename T>
|
|
void ReadVector(DataBuffer& a_Buffer, std::vector<T>& a_Data);
|
|
|
|
template <typename T>
|
|
void ReadList(DataBuffer& a_Buffer, std::list<T>& a_Data);
|
|
|
|
template <typename K, typename V>
|
|
void ReadMap(DataBuffer& a_Buffer, std::map<K, V>& a_Data);
|
|
|
|
template <typename K, typename V>
|
|
void ReadUnorderedMap(DataBuffer& a_Buffer, std::unordered_map<K, V>& a_Data);
|
|
|
|
template <typename K, typename V>
|
|
void ReadPair(DataBuffer& a_Buffer, std::pair<K, V>& a_Data);
|
|
|
|
template <typename T, std::size_t S>
|
|
void ReadArray(DataBuffer& a_Buffer, std::array<T, S>& a_Data);
|
|
|
|
} // namespace details
|
|
|
|
|
|
|
|
|
|
/**
|
|
* \brief Append data to the buffer (converted to big endian)
|
|
*/
|
|
template <typename T, typename = typename std::enable_if_t<is_default_serializable_v<T>>>
|
|
DataBuffer& operator<<(DataBuffer& a_Buffer, const T& a_Data) {
|
|
if constexpr (std::is_class_v<T>) {
|
|
details::WriteFields(a_Buffer, a_Data);
|
|
} else {
|
|
details::WriteRaw(a_Buffer, a_Data);
|
|
}
|
|
return a_Buffer;
|
|
}
|
|
|
|
/**
|
|
* \brief Append a string to the buffer
|
|
* \warning Don't use it for binary data !
|
|
* \param str The string to append
|
|
*/
|
|
DataBuffer& operator<<(DataBuffer& a_Buffer, const std::string& str);
|
|
|
|
/**
|
|
* \brief Operator << to write a DataBuffer to an ostream
|
|
*/
|
|
std::ostream& operator<<(std::ostream& os, const DataBuffer& buffer);
|
|
|
|
/**
|
|
* \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& a_Buffer, const std::shared_ptr<T>& a_Data) {
|
|
details::WriteSharedPtr(a_Buffer, a_Data);
|
|
return a_Buffer;
|
|
}
|
|
|
|
/**
|
|
* \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& a_Buffer, const std::unique_ptr<T>& a_Data) {
|
|
details::WriteUniquePtr(a_Buffer, a_Data);
|
|
return a_Buffer;
|
|
}
|
|
|
|
/**
|
|
* \brief Append a vector to the buffer by first writing the size
|
|
* \param data The vector to append
|
|
*/
|
|
template <typename T>
|
|
DataBuffer& operator<<(DataBuffer& a_Buffer, const std::vector<T>& a_Data) {
|
|
details::WriteVector(a_Buffer, a_Data);
|
|
return a_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& a_Buffer, const std::list<T>& a_Data) {
|
|
details::WriteList(a_Buffer, a_Data);
|
|
return a_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& a_Buffer, const std::map<K, V>& a_Data) {
|
|
details::WriteMap(a_Buffer, a_Data);
|
|
return a_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& a_Buffer, const std::unordered_map<K, V>& a_Data) {
|
|
details::WriteUnorderedMap(a_Buffer, a_Data);
|
|
return a_Buffer;
|
|
}
|
|
|
|
/**
|
|
* \brief Append a pair to the buffer
|
|
* \param data The pair to append
|
|
*/
|
|
template <typename K, typename V>
|
|
DataBuffer& operator<<(DataBuffer& a_Buffer, const std::pair<K, V>& a_Data) {
|
|
details::WritePair(a_Buffer, a_Data);
|
|
return a_Buffer;
|
|
}
|
|
|
|
/**
|
|
* \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& a_Buffer, const std::array<T, Size>& a_Data) {
|
|
details::WriteArray(a_Buffer, a_Data);
|
|
return a_Buffer;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* \brief Read some data from the buffer and assign to desired variable
|
|
*/
|
|
template <typename T, typename = typename std::enable_if_t<is_default_serializable_v<T>>>
|
|
DataBuffer& operator>>(DataBuffer& a_Buffer, T& a_Data) {
|
|
if constexpr (std::is_class_v<T>) {
|
|
details::ReadFields(a_Buffer, a_Data);
|
|
} else {
|
|
details::ReadRaw(a_Buffer, a_Data);
|
|
}
|
|
return a_Buffer;
|
|
}
|
|
|
|
/**
|
|
* \brief Read some data from the buffer and assign to the new buffer
|
|
* \param data The buffer to assign
|
|
*/
|
|
DataBuffer& operator>>(DataBuffer& a_Buffer, DataBuffer& a_Data);
|
|
|
|
/**
|
|
* \brief Read a string from the buffer
|
|
* \param str The string to assign in the new buffer
|
|
* \warning Don't use it for binary data !
|
|
*/
|
|
DataBuffer& operator>>(DataBuffer& a_Buffer, std::string& str);
|
|
|
|
/**
|
|
* \brief Read a pointer
|
|
*/
|
|
template <typename T, typename = typename std::enable_if_t<!std::is_abstract_v<T>>>
|
|
DataBuffer& operator>>(DataBuffer& a_Buffer, std::shared_ptr<T>& a_Data) {
|
|
details::ReadSharedPtr(a_Buffer, a_Data);
|
|
return a_Buffer;
|
|
}
|
|
|
|
/**
|
|
* \brief Read a pointer
|
|
*/
|
|
template <typename T, typename = typename std::enable_if_t<!std::is_abstract_v<T>>>
|
|
DataBuffer& operator>>(DataBuffer& a_Buffer, std::unique_ptr<T>& a_Data) {
|
|
details::ReadUniquePtr(a_Buffer, a_Data);
|
|
return a_Buffer;
|
|
}
|
|
|
|
/**
|
|
* \brief Read a vector (size + data) from the buffer
|
|
* \pre The vector is assumed to be empty
|
|
*/
|
|
template <typename T>
|
|
DataBuffer& operator>>(DataBuffer& a_Buffer, std::vector<T>& a_Data) {
|
|
details::ReadVector(a_Buffer, a_Data);
|
|
return a_Buffer;
|
|
}
|
|
|
|
/**
|
|
* \brief Read a list (size + data) from the buffer
|
|
* \pre The list is assumed to be empty
|
|
*/
|
|
template <typename T>
|
|
DataBuffer& operator>>(DataBuffer& a_Buffer, std::list<T>& a_Data) {
|
|
details::ReadList(a_Buffer, a_Data);
|
|
return a_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& a_Buffer, std::map<K, V>& a_Data) {
|
|
details::ReadMap(a_Buffer, a_Data);
|
|
return a_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& a_Buffer, std::unordered_map<K, V>& a_Data) {
|
|
details::ReadUnorderedMap(a_Buffer, a_Data);
|
|
return a_Buffer;
|
|
}
|
|
|
|
/**
|
|
* \brief Read a pair
|
|
*/
|
|
template <typename K, typename V>
|
|
DataBuffer& operator>>(DataBuffer& a_Buffer, std::pair<K, V>& a_Data) {
|
|
details::ReadPair(a_Buffer, a_Data);
|
|
return a_Buffer;
|
|
}
|
|
|
|
/**
|
|
* \brief Read an array from the buffer
|
|
*/
|
|
template <std::size_t Size, typename T>
|
|
DataBuffer& operator>>(DataBuffer& a_Buffer, std::array<T, Size>& a_Data) {
|
|
details::ReadArray(a_Buffer, a_Data);
|
|
return a_Buffer;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
namespace details {
|
|
|
|
template <typename T>
|
|
void WriteRaw(DataBuffer& a_Buffer, T a_Data) {
|
|
a_Buffer.Append(a_Data);
|
|
SwapBytes(a_Buffer.data() + a_Buffer.GetReadOffset() - sizeof(T), a_Buffer.data() + a_Buffer.GetReadOffset());
|
|
}
|
|
|
|
template <typename T>
|
|
void WriteFields(DataBuffer& a_Buffer, const T& a_Data) {
|
|
boost::pfr::for_each_field(a_Data, [&a_Buffer](const auto& a_Field) { a_Buffer << a_Field; });
|
|
}
|
|
|
|
template <typename T>
|
|
void WriteSharedPtr(DataBuffer& a_Buffer, const std::shared_ptr<T>& a_Data) {
|
|
a_Buffer << *a_Data;
|
|
}
|
|
|
|
template <typename T>
|
|
void WriteUniquePtr(DataBuffer& a_Buffer, const std::unique_ptr<T>& a_Data) {
|
|
a_Buffer << *a_Data;
|
|
}
|
|
|
|
template <typename T>
|
|
void WriteVector(DataBuffer& a_Buffer, const std::vector<T>& a_Data) {
|
|
a_Buffer << VarInt{a_Data.size()};
|
|
for (const auto& element : a_Data) {
|
|
a_Buffer << element;
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void WriteList(DataBuffer& a_Buffer, const std::list<T>& a_Data) {
|
|
a_Buffer << VarInt{a_Data.size()};
|
|
for (const auto& element : a_Data) {
|
|
a_Buffer << element;
|
|
}
|
|
}
|
|
|
|
template <typename K, typename V>
|
|
void WriteMap(DataBuffer& a_Buffer, const std::map<K, V>& a_Data) {
|
|
a_Buffer << VarInt{a_Data.size()};
|
|
for (const auto& [key, value] : a_Data) {
|
|
a_Buffer << key << value;
|
|
}
|
|
}
|
|
|
|
template <typename K, typename V>
|
|
void WriteUnorderedMap(DataBuffer& a_Buffer, const std::unordered_map<K, V>& a_Data) {
|
|
a_Buffer << VarInt{a_Data.size()};
|
|
for (const auto& [key, value] : a_Data) {
|
|
a_Buffer << key << value;
|
|
}
|
|
}
|
|
|
|
template <typename K, typename V>
|
|
void WritePair(DataBuffer& a_Buffer, const std::pair<K, V>& a_Data) {
|
|
a_Buffer << a_Data.first << a_Data.second;
|
|
}
|
|
|
|
template <typename T, std::size_t S>
|
|
void WriteArray(DataBuffer& a_Buffer, const std::array<T, S>& a_Data) {
|
|
for (const auto& element : a_Data) {
|
|
a_Buffer << element;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
template <typename T>
|
|
void ReadRaw(DataBuffer& a_Buffer, T& a_Data) {
|
|
a_Buffer.Read(a_Data);
|
|
SwapBytes(a_Data);
|
|
}
|
|
|
|
template <typename T>
|
|
void ReadFields(DataBuffer& a_Buffer, T& a_Data) {
|
|
boost::pfr::for_each_field(a_Data, [&a_Buffer](auto& a_Field) { a_Buffer >> a_Field; });
|
|
}
|
|
|
|
template <typename T>
|
|
void ReadSharedPtr(DataBuffer& a_Buffer, std::shared_ptr<T>& a_Data) {
|
|
a_Data = std::make_shared<T>();
|
|
a_Buffer >> *a_Data;
|
|
}
|
|
|
|
template <typename T>
|
|
void ReadUniquePtr(DataBuffer& a_Buffer, std::unique_ptr<T>& a_Data) {
|
|
a_Data = std::make_unique<T>();
|
|
a_Buffer >> *a_Data;
|
|
}
|
|
|
|
template <typename T>
|
|
void ReadVector(DataBuffer& a_Buffer, std::vector<T>& a_Data) {
|
|
VarInt arraySize;
|
|
a_Buffer >> arraySize;
|
|
for (std::size_t i = 0; i < arraySize.GetValue(); i++) {
|
|
T newElement;
|
|
a_Buffer >> newElement;
|
|
a_Data.push_back(newElement);
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void ReadList(DataBuffer& a_Buffer, std::list<T>& a_Data) {
|
|
VarInt arraySize;
|
|
a_Buffer >> arraySize;
|
|
for (std::size_t i = 0; i < arraySize.GetValue(); i++) {
|
|
T newElement;
|
|
a_Buffer >> newElement;
|
|
a_Data.push_back(newElement);
|
|
}
|
|
}
|
|
|
|
template <typename K, typename V>
|
|
void ReadMap(DataBuffer& a_Buffer, std::map<K, V>& a_Data) {
|
|
VarInt mapSize;
|
|
a_Buffer >> mapSize;
|
|
for (std::size_t i = 0; i < mapSize.GetValue(); i++) {
|
|
K newKey;
|
|
V newValue;
|
|
a_Buffer >> newKey >> newValue;
|
|
a_Data.emplace(newKey, newValue);
|
|
}
|
|
}
|
|
|
|
template <typename K, typename V>
|
|
void ReadUnorderedMap(DataBuffer& a_Buffer, std::unordered_map<K, V>& a_Data) {
|
|
VarInt mapSize;
|
|
a_Buffer >> mapSize;
|
|
for (std::size_t i = 0; i < mapSize.GetValue(); i++) {
|
|
K newKey;
|
|
V newValue;
|
|
a_Buffer >> newKey >> newValue;
|
|
a_Data.emplace(newKey, newValue);
|
|
}
|
|
}
|
|
|
|
template <typename K, typename V>
|
|
void ReadPair(DataBuffer& a_Buffer, std::pair<K, V>& a_Data) {
|
|
a_Buffer >> a_Data.first >> a_Data.a_Data;
|
|
}
|
|
|
|
template <typename T, std::size_t S>
|
|
void ReadArray(DataBuffer& a_Buffer, std::array<T, S>& a_Data) {
|
|
for (std::size_t i = 0; i < S; i++) {
|
|
T newElement;
|
|
a_Buffer >> newElement;
|
|
a_Data[i] = newElement;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace details
|
|
|
|
} // namespace sp
|