games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2025-11-23 22:37:55 +02:00
Code Issues Releases Activity

Cleanup serializer/deserializer code

Browse Source
This commit is contained in:
Ivan Savenko
2025-04-08 16:37:38 +03:00
parent 93b18ee94b
commit f9989d9152
5 changed files with 245 additions and 237 deletions
Download Patch File Download Diff File Expand all files Collapse all files

208
lib/serializer/BinarySerializer.h
View File

@@ -11,10 +11,8 @@
#include "CSerializer.h"
#include "CTypeList.h"
#include "SerializerReflection.h"
#include "ESerializationVersion.h"
#include "Serializeable.h"
#include "../mapObjects/CArmedInstance.h"
#include "SerializerReflection.h"
VCMI_LIB_NAMESPACE_BEGIN
@@ -25,44 +23,13 @@ VCMI_LIB_NAMESPACE_BEGIN
/// VCMI Classes: recursively serialize them via ClassName::serialize( BinarySerializer &, int version) call
class BinarySerializer
{
IBinaryWriter * writer;
template<typename Handler>
struct VariantVisitorSaver
{
Handler &h;
VariantVisitorSaver(Handler &H):h(H)
{
}
template <typename T>
void operator()(const T &t)
{
h & t;
}
};
void write(const void * data, unsigned size)
{
writer->write(reinterpret_cast<const std::byte*>(data), size);
};
public:
using Version = ESerializationVersion;
std::map<std::string, uint32_t> savedStrings;
std::map<const Serializeable*, uint32_t> savedPointers;
static constexpr bool saving = true;
Version version = Version::CURRENT;
static constexpr bool trackSerializedPointers = true;
static constexpr bool saving = true;
bool loadingGamestate = false;
bool hasFeature(Version what) const
{
return version >= what;
};
BinarySerializer(IBinaryWriter * w)
: writer(w)
{
@@ -72,14 +39,47 @@ public:
BinarySerializer & operator&(const T & t)
{
this->save(t);
return * this;
return *this;
}
void clear()
{
savedPointers.clear();
}
private:
std::map<std::string, uint32_t> savedStrings;
std::map<const Serializeable*, uint32_t> savedPointers;
IBinaryWriter * writer;
static constexpr bool trackSerializedPointers = true;
template<typename Handler>
struct VariantVisitorSaver
{
Handler & h;
VariantVisitorSaver(Handler & H)
: h(H)
{
}
template<typename T>
void operator()(const T & t)
{
h & t;
}
};
void write(const void * data, unsigned size)
{
writer->write(reinterpret_cast<const std::byte *>(data), size);
};
void saveEncodedInteger(int64_t value)
{
uint64_t valueUnsigned = std::abs(value);
while (valueUnsigned > 0x3f)
while(valueUnsigned > 0x3f)
{
uint8_t byteValue = (valueUnsigned & 0x7f) | 0x80;
valueUnsigned = valueUnsigned >> 7;
@@ -87,30 +87,30 @@ public:
}
uint8_t lastByteValue = valueUnsigned & 0x3f;
if (value < 0)
if(value < 0)
lastByteValue |= 0x40;
save(lastByteValue);
}
template < typename T, typename std::enable_if_t < std::is_same_v<T, bool>, int > = 0 >
void save(const T &data)
template<typename T, typename std::enable_if_t<std::is_same_v<T, bool>, int> = 0>
void save(const T & data)
{
uint8_t writ = static_cast<uint8_t>(data);
save(writ);
}
template < class T, typename std::enable_if_t < std::is_floating_point_v<T>, int > = 0 >
void save(const T &data)
template<class T, typename std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
void save(const T & data)
{
// save primitive - simply dump binary data to output
this->write(static_cast<const void *>(&data), sizeof(data));
}
template < class T, typename std::enable_if_t < std::is_integral_v<T> && !std::is_same_v<T, bool>, int > = 0 >
void save(const T &data)
template<class T, typename std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<T, bool>, int> = 0>
void save(const T & data)
{
if constexpr (sizeof(T) == 1)
if constexpr(sizeof(T) == 1)
{
// save primitive - simply dump binary data to output
this->write(static_cast<const void *>(&data), sizeof(data));
@@ -121,28 +121,28 @@ public:
}
}
void save(const Version &data)
void save(const Version & data)
{
this->write(static_cast<const void *>(&data), sizeof(data));
}
template < typename T, typename std::enable_if_t < std::is_enum_v<T>, int > = 0 >
void save(const T &data)
template<typename T, typename std::enable_if_t<std::is_enum_v<T>, int> = 0>
void save(const T & data)
{
int32_t writ = static_cast<int32_t>(data);
*this & writ;
}
template < typename T, typename std::enable_if_t < std::is_array_v<T>, int > = 0 >
void save(const T &data)
template<typename T, typename std::enable_if_t<std::is_array_v<T>, int> = 0>
void save(const T & data)
{
uint32_t size = std::size(data);
for(uint32_t i=0; i < size; i++)
for(uint32_t i = 0; i < size; i++)
*this & data[i];
}
template<typename T>
void saveRawPointer(const T & data)
template<class T, typename std::enable_if_t<std::is_pointer_v<T>, int> = 0>
void save(const T & data)
{
//write if pointer is not nullptr
bool isNull = (data == nullptr);
@@ -156,7 +156,7 @@ public:
{
// We might have an object that has multiple inheritance and store it via the non-first base pointer.
// Therefore, all pointers need to be normalized to the actual object address.
const auto * actualPointer = static_cast<const Serializeable*>(data);
const auto * actualPointer = static_cast<const Serializeable *>(data);
auto i = savedPointers.find(actualPointer);
if(i != savedPointers.end())
{
@@ -181,10 +181,10 @@ public:
CSerializationApplier::getInstance().getApplier(tid)->savePtr(*this, static_cast<const Serializeable*>(data)); //call serializer specific for our real type
}
template < typename T, typename std::enable_if_t < is_serializeable<BinarySerializer, T>::value, int > = 0 >
void save(const T &data)
template<typename T, typename std::enable_if_t<is_serializeable<BinarySerializer, T>::value, int> = 0>
void save(const T & data)
{
const_cast<T&>(data).serialize(*this);
const_cast<T &>(data).serialize(*this);
}
void save(const std::monostate & data)
@@ -192,42 +192,42 @@ public:
// no-op
}
template <typename T>
void save(const std::shared_ptr<T> &data)
template<typename T>
void save(const std::shared_ptr<T> & data)
{
T *internalPtr = data.get();
saveRawPointer(internalPtr);
T * internalPtr = data.get();
save(internalPtr);
}
template <typename T>
void save(const std::shared_ptr<const T> &data)
template<typename T>
void save(const std::shared_ptr<const T> & data)
{
const T *internalPtr = data.get();
saveRawPointer(internalPtr);
const T * internalPtr = data.get();
save(internalPtr);
}
template <typename T>
void save(const std::unique_ptr<T> &data)
template<typename T>
void save(const std::unique_ptr<T> & data)
{
T *internalPtr = data.get();
saveRawPointer(internalPtr);
T * internalPtr = data.get();
save(internalPtr);
}
template <typename T, typename std::enable_if_t < !std::is_same_v<T, bool >, int > = 0>
void save(const std::vector<T> &data)
template<typename T, typename std::enable_if_t<!std::is_same_v<T, bool>, int> = 0>
void save(const std::vector<T> & data)
{
uint32_t length = data.size();
*this & length;
for(uint32_t i=0;i<length;i++)
for(uint32_t i = 0; i < length; i++)
save(data[i]);
}
template <typename T, size_t N>
void save(const boost::container::small_vector<T, N>& data)
template<typename T, size_t N>
void save(const boost::container::small_vector<T, N> & data)
{
uint32_t length = data.size();
*this& length;
for (uint32_t i = 0; i < length; i++)
*this & length;
for(uint32_t i = 0; i < length; i++)
save(data[i]);
}
template <typename T, typename std::enable_if_t < !std::is_same_v<T, bool >, int > = 0>
template<typename T, typename std::enable_if_t<!std::is_same_v<T, bool>, int> = 0>
void save(const std::deque<T> & data)
{
uint32_t length = data.size();
@@ -235,30 +235,30 @@ public:
for(uint32_t i = 0; i < length; i++)
save(data[i]);
}
template <typename T, size_t N>
void save(const std::array<T, N> &data)
template<typename T, size_t N>
void save(const std::array<T, N> & data)
{
for(uint32_t i=0; i < N; i++)
for(uint32_t i = 0; i < N; i++)
save(data[i]);
}
template <typename T>
void save(const std::set<T> &data)
template<typename T>
void save(const std::set<T> & data)
{
uint32_t length = data.size();
save(length);
for(auto i = data.begin(); i != data.end(); i++)
save(*i);
}
template <typename T, typename U>
void save(const std::unordered_set<T, U> &data)
template<typename T, typename U>
void save(const std::unordered_set<T, U> & data)
{
uint32_t length = data.size();
*this & length;
for(auto i = data.begin(); i != data.end(); i++)
save(*i);
}
template <typename T>
void save(const std::list<T> &data)
template<typename T>
void save(const std::list<T> & data)
{
uint32_t length = data.size();
*this & length;
@@ -266,9 +266,9 @@ public:
save(*i);
}
void save(const std::string &data)
void save(const std::string & data)
{
if (data.empty())
if(data.empty())
{
save(static_cast<uint32_t>(0));
return;
@@ -276,7 +276,7 @@ public:
auto it = savedStrings.find(data);
if (it == savedStrings.end())
if(it == savedStrings.end())
{
save(static_cast<uint32_t>(data.length()));
this->write(static_cast<const void *>(data.data()), data.size());
@@ -293,14 +293,14 @@ public:
}
}
template <typename T1, typename T2>
void save(const std::pair<T1,T2> &data)
template<typename T1, typename T2>
void save(const std::pair<T1, T2> & data)
{
save(data.first);
save(data.second);
}
template <typename T1, typename T2>
void save(const std::unordered_map<T1,T2> &data)
template<typename T1, typename T2>
void save(const std::unordered_map<T1, T2> & data)
{
*this & static_cast<uint32_t>(data.size());
for(auto i = data.begin(); i != data.end(); i++)
@@ -309,8 +309,8 @@ public:
save(i->second);
}
}
template <typename T1, typename T2>
void save(const std::map<T1,T2> &data)
template<typename T1, typename T2>
void save(const std::map<T1, T2> & data)
{
*this & static_cast<uint32_t>(data.size());
for(auto i = data.begin(); i != data.end(); i++)
@@ -319,8 +319,8 @@ public:
save(i->second);
}
}
template <typename T1, typename T2>
void save(const std::multimap<T1, T2> &data)
template<typename T1, typename T2>
void save(const std::multimap<T1, T2> & data)
{
*this & static_cast<uint32_t>(data.size());
for(auto i = data.begin(); i != data.end(); i++)
@@ -352,8 +352,8 @@ public:
}
}
template <typename T>
void save(const boost::multi_array<T, 3> &data)
template<typename T>
void save(const boost::multi_array<T, 3> & data)
{
uint32_t length = data.num_elements();
*this & length;
@@ -365,21 +365,21 @@ public:
for(uint32_t i = 0; i < length; i++)
save(data.data()[i]);
}
template <std::size_t T>
void save(const std::bitset<T> &data)
template<std::size_t T>
void save(const std::bitset<T> & data)
{
static_assert(T <= 64);
if constexpr (T <= 16)
if constexpr(T <= 16)
{
auto writ = static_cast<uint16_t>(data.to_ulong());
save(writ);
}
else if constexpr (T <= 32)
else if constexpr(T <= 32)
{
auto writ = static_cast<uint32_t>(data.to_ulong());
save(writ);
}
else if constexpr (T <= 64)
else if constexpr(T <= 64)
{
auto writ = static_cast<uint64_t>(data.to_ulong());
save(writ);