/* * BinarySerializer.h, part of VCMI engine * * Authors: listed in file AUTHORS in main folder * * License: GNU General Public License v2.0 or later * Full text of license available in license.txt file, in main folder * */ #pragma once #include "CSerializer.h" #include "CTypeList.h" #include "ESerializationVersion.h" #include "Serializeable.h" #include "../mapObjects/CArmedInstance.h" VCMI_LIB_NAMESPACE_BEGIN class DLL_LINKAGE CSaverBase { protected: IBinaryWriter * writer; public: CSaverBase(IBinaryWriter * w): writer(w){}; void write(const void * data, unsigned size) { writer->write(reinterpret_cast(data), size); }; }; /// Main class for serialization of classes into binary form /// Behaviour for various classes is following: /// Primitives: copy memory into underlying stream (defined in CSaverBase) /// Containers: custom overloaded method that decouples class into primitives /// VCMI Classes: recursively serialize them via ClassName::serialize( BinarySerializer &, int version) call class BinarySerializer : public CSaverBase { template struct VariantVisitorSaver { Handler &h; VariantVisitorSaver(Handler &H):h(H) { } template void operator()(const T &t) { h & t; } }; template bool saveIfStackInstance(const T &data) { return false; } template bool saveIfStackInstance(const CStackInstance* const &data) { assert(data->armyObj); SlotID slot; if(data->getNodeType() == CBonusSystemNode::COMMANDER) slot = SlotID::COMMANDER_SLOT_PLACEHOLDER; else slot = data->armyObj->findStack(data); assert(slot != SlotID()); save(data->armyObj->id); save(slot); if (data->armyObj->id != ObjectInstanceID::NONE) return true; else return false; } template class CPointerSaver; class CBasicPointerSaver { public: virtual void savePtr(CSaverBase &ar, const Serializeable *data) const =0; virtual ~CBasicPointerSaver() = default; template static CBasicPointerSaver *getApplier(const T * t=nullptr) { return new CPointerSaver(); } }; template class CPointerSaver : public CBasicPointerSaver { public: void savePtr(CSaverBase &ar, const Serializeable *data) const override { auto & s = static_cast(ar); const T *ptr = dynamic_cast(data); //T is most derived known type, it's time to call actual serialize const_cast(ptr)->serialize(s); } }; CApplier applier; public: using Version = ESerializationVersion; std::map savedStrings; std::map savedPointers; Version version = Version::CURRENT; bool smartPointerSerialization; bool saving; bool hasFeature(Version what) const { return version >= what; }; DLL_LINKAGE BinarySerializer(IBinaryWriter * w); template void registerType(const Base * b = nullptr, const Derived * d = nullptr) { applier.registerType(b, d); } template BinarySerializer & operator&(const T & t) { this->save(t); return * this; } void saveEncodedInteger(int64_t value) { uint64_t valueUnsigned = std::abs(value); while (valueUnsigned > 0x3f) { uint8_t byteValue = (valueUnsigned & 0x7f) | 0x80; valueUnsigned = valueUnsigned >> 7; save(byteValue); } uint8_t lastByteValue = valueUnsigned & 0x3f; if (value < 0) lastByteValue |= 0x40; save(lastByteValue); } template < typename T, typename std::enable_if_t < std::is_same_v, int > = 0 > void save(const T &data) { uint8_t writ = static_cast(data); save(writ); } template < class T, typename std::enable_if_t < std::is_floating_point_v, int > = 0 > void save(const T &data) { // save primitive - simply dump binary data to output this->write(static_cast(&data), sizeof(data)); } template < class T, typename std::enable_if_t < std::is_integral_v && !std::is_same_v, int > = 0 > void save(const T &data) { if constexpr (sizeof(T) == 1) { // save primitive - simply dump binary data to output this->write(static_cast(&data), sizeof(data)); } else { if (hasFeature(Version::COMPACT_INTEGER_SERIALIZATION)) saveEncodedInteger(data); else this->write(static_cast(&data), sizeof(data)); } } void save(const Version &data) { this->write(static_cast(&data), sizeof(data)); } template < typename T, typename std::enable_if_t < std::is_enum_v, int > = 0 > void save(const T &data) { int32_t writ = static_cast(data); *this & writ; } template < typename T, typename std::enable_if_t < std::is_array_v, int > = 0 > void save(const T &data) { uint32_t size = std::size(data); for(uint32_t i=0; i < size; i++) *this & data[i]; } template < typename T, typename std::enable_if_t < std::is_pointer_v, int > = 0 > void save(const T &data) { //write if pointer is not nullptr bool isNull = (data == nullptr); save(isNull); //if pointer is nullptr then we don't need anything more... if(data == nullptr) return; savePointerImpl(data); } template < typename T, typename std::enable_if_t < std::is_base_of_v>, int > = 0 > void savePointerImpl(const T &data) { auto index = data->getId(); save(index); } template < typename T, typename std::enable_if_t < !std::is_base_of_v>, int > = 0 > void savePointerImpl(const T &data) { typedef typename std::remove_const_t> TObjectType; if(writer->smartVectorMembersSerialization) { typedef typename VectorizedTypeFor::type VType; typedef typename VectorizedIDType::type IDType; if(const auto *info = writer->getVectorizedTypeInfo()) { IDType id = writer->getIdFromVectorItem(*info, data); save(id); if(id != IDType(-1)) //vector id is enough return; } } if(writer->sendStackInstanceByIds) { const bool gotSaved = saveIfStackInstance(data); if(gotSaved) return; } if(smartPointerSerialization) { // 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(data); auto i = savedPointers.find(actualPointer); if(i != savedPointers.end()) { //this pointer has been already serialized - write only it's id save(i->second); return; } //give id to this pointer uint32_t pid = savedPointers.size(); savedPointers[actualPointer] = pid; save(pid); } //write type identifier uint16_t tid = CTypeList::getInstance().getTypeID(data); save(tid); if(!tid) save(*data); //if type is unregistered simply write all data in a standard way else applier.getApplier(tid)->savePtr(*this, static_cast(data)); //call serializer specific for our real type } template < typename T, typename std::enable_if_t < is_serializeable::value, int > = 0 > void save(const T &data) { const_cast(data).serialize(*this); } void save(const std::monostate & data) { // no-op } template void save(const std::shared_ptr &data) { T *internalPtr = data.get(); save(internalPtr); } template void save(const std::shared_ptr &data) { const T *internalPtr = data.get(); save(internalPtr); } template void save(const std::unique_ptr &data) { T *internalPtr = data.get(); save(internalPtr); } template , int > = 0> void save(const std::vector &data) { uint32_t length = data.size(); *this & length; for(uint32_t i=0;i, int > = 0> void save(const std::deque & data) { uint32_t length = data.size(); *this & length; for(uint32_t i = 0; i < length; i++) save(data[i]); } template void save(const std::array &data) { for(uint32_t i=0; i < N; i++) save(data[i]); } template void save(const std::set &data) { auto & d = const_cast &>(data); uint32_t length = d.size(); save(length); for(auto i = d.begin(); i != d.end(); i++) save(*i); } template void save(const std::unordered_set &data) { auto & d = const_cast &>(data); uint32_t length = d.size(); *this & length; for(auto i = d.begin(); i != d.end(); i++) save(*i); } template void save(const std::list &data) { auto & d = const_cast &>(data); uint32_t length = d.size(); *this & length; for(auto i = d.begin(); i != d.end(); i++) save(*i); } void save(const std::string &data) { if (hasFeature(Version::COMPACT_STRING_SERIALIZATION)) { if (data.empty()) { save(static_cast(0)); return; } auto it = savedStrings.find(data); if (it == savedStrings.end()) { save(static_cast(data.length())); this->write(static_cast(data.data()), data.size()); // -1, -2... int32_t newStringID = -1 - savedStrings.size(); savedStrings[data] = newStringID; } else { int32_t index = it->second; save(index); } } else { save(static_cast(data.length())); this->write(static_cast(data.data()), data.size()); } } template void save(const std::pair &data) { save(data.first); save(data.second); } template void save(const std::unordered_map &data) { *this & static_cast(data.size()); for(auto i = data.begin(); i != data.end(); i++) { save(i->first); save(i->second); } } template void save(const std::map &data) { *this & static_cast(data.size()); for(auto i = data.begin(); i != data.end(); i++) { save(i->first); save(i->second); } } template void save(const std::multimap &data) { *this & static_cast(data.size()); for(auto i = data.begin(); i != data.end(); i++) { save(i->first); save(i->second); } } template void save(const std::variant & data) { int32_t which = data.index(); save(which); VariantVisitorSaver visitor(*this); std::visit(visitor, data); } template void save(const std::optional & data) { if(data) { save(static_cast(1)); save(*data); } else { save(static_cast(0)); } } template void save(const boost::multi_array &data) { uint32_t length = data.num_elements(); *this & length; auto shape = data.shape(); uint32_t x = shape[0]; uint32_t y = shape[1]; uint32_t z = shape[2]; *this & x & y & z; for(uint32_t i = 0; i < length; i++) save(data.data()[i]); } template void save(const std::bitset &data) { static_assert(T <= 64); if constexpr (T <= 16) { auto writ = static_cast(data.to_ulong()); save(writ); } else if constexpr (T <= 32) { auto writ = static_cast(data.to_ulong()); save(writ); } else if constexpr (T <= 64) { auto writ = static_cast(data.to_ulong()); save(writ); } } }; VCMI_LIB_NAMESPACE_END