Connection.h 44 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740
  1. /*
  2. * Connection.h, part of VCMI engine
  3. *
  4. * Authors: listed in file AUTHORS in main folder
  5. *
  6. * License: GNU General Public License v2.0 or later
  7. * Full text of license available in license.txt file, in main folder
  8. *
  9. */
  10. #pragma once
  11. #include <typeinfo> //XXX this is in namespace std if you want w/o use typeinfo.h?
  12. #include <type_traits>
  13. #include <boost/mpl/eval_if.hpp>
  14. #include <boost/mpl/equal_to.hpp>
  15. #include <boost/mpl/int.hpp>
  16. #include <boost/mpl/identity.hpp>
  17. #include <boost/mpl/for_each.hpp>
  18. #include <boost/any.hpp>
  19. #include "ConstTransitivePtr.h"
  20. #include "CCreatureSet.h" //for CStackInstance
  21. #include "mapObjects/CGHeroInstance.h"
  22. #include "mapping/CCampaignHandler.h" //for CCampaignState
  23. #include "rmg/CMapGenerator.h" // for CMapGenOptions
  24. const ui32 version = 755;
  25. const ui32 minSupportedVersion = 753;
  26. class CISer;
  27. class COSer;
  28. class CConnection;
  29. class CGObjectInstance;
  30. class CStackInstance;
  31. class CGameState;
  32. class CCreature;
  33. class LibClasses;
  34. class CHero;
  35. struct CPack;
  36. extern DLL_LINKAGE LibClasses * VLC;
  37. namespace mpl = boost::mpl;
  38. const std::string SAVEGAME_MAGIC = "VCMISVG";
  39. namespace boost
  40. {
  41. namespace asio
  42. {
  43. namespace ip
  44. {
  45. class tcp;
  46. }
  47. class io_service;
  48. template <typename Protocol> class stream_socket_service;
  49. template <typename Protocol,typename StreamSocketService>
  50. class basic_stream_socket;
  51. template <typename Protocol> class socket_acceptor_service;
  52. template <typename Protocol,typename SocketAcceptorService>
  53. class basic_socket_acceptor;
  54. }
  55. class mutex;
  56. }
  57. enum SerializationLvl
  58. {
  59. Wrong=0,
  60. Boolean,
  61. Primitive,
  62. Array,
  63. Pointer,
  64. Enum,
  65. Serializable,
  66. BooleanVector
  67. };
  68. struct TypeComparer
  69. {
  70. bool operator()(const std::type_info *a, const std::type_info *b) const
  71. {
  72. return a->before(*b);
  73. }
  74. };
  75. struct IPointerCaster
  76. {
  77. virtual boost::any castRawPtr(const boost::any &ptr) const = 0; // takes From*, performs dynamic cast, returns To*
  78. virtual boost::any castSharedPtr(const boost::any &ptr) const = 0; // takes std::shared_ptr<From>, performs dynamic cast, returns std::shared_ptr<To>
  79. virtual boost::any castWeakPtr(const boost::any &ptr) const = 0; // takes std::weak_ptr<From>, performs dynamic cast, returns std::weak_ptr<To>. The object under poitner must live.
  80. //virtual boost::any castUniquePtr(const boost::any &ptr) const = 0; // takes std::unique_ptr<From>, performs dynamic cast, returns std::unique_ptr<To>
  81. };
  82. template <typename From, typename To>
  83. struct PointerCaster : IPointerCaster
  84. {
  85. virtual boost::any castRawPtr(const boost::any &ptr) const override // takes void* pointing to From object, performs dynamic cast, returns void* pointing to To object
  86. {
  87. From * from = (From*)boost::any_cast<void*>(ptr);
  88. To * ret = dynamic_cast<To*>(from);
  89. return (void*)ret;
  90. }
  91. // Helper function performing casts between smart pointers using dynamic_pointer_cast
  92. template<typename SmartPt>
  93. boost::any castSmartPtr(const boost::any &ptr) const
  94. {
  95. try
  96. {
  97. auto from = boost::any_cast<SmartPt>(ptr);
  98. auto ret = std::dynamic_pointer_cast<To>(from);
  99. return ret;
  100. }
  101. catch(std::exception &e)
  102. {
  103. THROW_FORMAT("Failed cast %s -> %s. Given argument was %s. Error message: %s", typeid(From).name() % typeid(To).name() % ptr.type().name() % e.what());
  104. }
  105. }
  106. virtual boost::any castSharedPtr(const boost::any &ptr) const override
  107. {
  108. return castSmartPtr<std::shared_ptr<From>>(ptr);
  109. }
  110. virtual boost::any castWeakPtr(const boost::any &ptr) const override
  111. {
  112. auto from = boost::any_cast<std::weak_ptr<From>>(ptr);
  113. return castSmartPtr<std::shared_ptr<From>>(from.lock());
  114. }
  115. // virtual boost::any castUniquePtr(const boost::any &ptr) const override
  116. // {
  117. // return castSmartPtr<std::unique_ptr<From>>(ptr);
  118. // }
  119. };
  120. class DLL_LINKAGE CTypeList
  121. {
  122. public:
  123. struct TypeDescriptor;
  124. typedef std::shared_ptr<TypeDescriptor> TypeInfoPtr;
  125. struct TypeDescriptor
  126. {
  127. ui16 typeID;
  128. const char *name;
  129. std::vector<TypeInfoPtr> children, parents;
  130. };
  131. private:
  132. std::map<const std::type_info *, TypeInfoPtr, TypeComparer> typeInfos;
  133. std::map<std::pair<TypeInfoPtr, TypeInfoPtr>, std::unique_ptr<const IPointerCaster>> casters; //for each pair <Base, Der> we provide a caster (each registered relations creates a single entry here)
  134. CTypeList(CTypeList &)
  135. {
  136. // This type is non-copyable.
  137. // Unfortunately on Windows it is required for DLL_EXPORT-ed type to provide copy c-tor, so we can't =delete it.
  138. assert(0);
  139. }
  140. CTypeList &operator=(CTypeList &)
  141. {
  142. // As above.
  143. assert(0);
  144. return *this;
  145. }
  146. public:
  147. CTypeList();
  148. TypeInfoPtr registerType(const std::type_info *type);
  149. template <typename Base, typename Derived>
  150. void registerType(const Base * b = nullptr, const Derived * d = nullptr)
  151. {
  152. static_assert(std::is_base_of<Base, Derived>::value, "First registerType template parameter needs to ba a base class of the second one.");
  153. static_assert(std::has_virtual_destructor<Base>::value, "Base class needs to have a virtual destructor.");
  154. static_assert(!std::is_same<Base, Derived>::value, "Parameters of registerTypes should be two diffrenet types.");
  155. auto bt = getTypeInfo(b), dt = getTypeInfo(d); //obtain std::type_info
  156. auto bti = registerType(bt), dti = registerType(dt); //obtain our TypeDescriptor
  157. // register the relation between classes
  158. bti->children.push_back(dti);
  159. dti->parents.push_back(bti);
  160. casters[std::make_pair(bti, dti)] = make_unique<const PointerCaster<Base, Derived>>();
  161. casters[std::make_pair(dti, bti)] = make_unique<const PointerCaster<Derived, Base>>();
  162. }
  163. ui16 getTypeID(const std::type_info *type);
  164. TypeInfoPtr getTypeDescriptor(const std::type_info *type, bool throws = true); //if not throws, failure returns nullptr
  165. template <typename T>
  166. ui16 getTypeID(const T * t = nullptr)
  167. {
  168. return getTypeID(getTypeInfo(t));
  169. }
  170. // Returns sequence of types starting from "from" and ending on "to". Every next type is derived from the previous.
  171. // Throws if there is no link registered.
  172. std::vector<TypeInfoPtr> castSequence(TypeInfoPtr from, TypeInfoPtr to);
  173. std::vector<TypeInfoPtr> castSequence(const std::type_info *from, const std::type_info *to);
  174. template<boost::any(IPointerCaster::*CastingFunction)(const boost::any &) const>
  175. boost::any castHelper(boost::any inputPtr, const std::type_info *fromArg, const std::type_info *toArg)
  176. {
  177. auto typesSequence = castSequence(fromArg, toArg);
  178. boost::any ptr = inputPtr;
  179. for(int i = 0; i < (int)typesSequence.size() - 1; i++)
  180. {
  181. auto &from = typesSequence[i];
  182. auto &to = typesSequence[i + 1];
  183. auto castingPair = std::make_pair(from, to);
  184. if(!casters.count(castingPair))
  185. THROW_FORMAT("Cannot find caster for conversion %s -> %s which is needed to cast %s -> %s", from->name % to->name % fromArg->name() % toArg->name());
  186. auto &caster = casters.at(castingPair);
  187. ptr = (*caster.*CastingFunction)(ptr); //Why does unique_ptr does not have operator->* ..?
  188. }
  189. return ptr;
  190. }
  191. template<typename TInput>
  192. void *castToMostDerived(const TInput *inputPtr)
  193. {
  194. auto &baseType = typeid(typename std::remove_cv<TInput>::type);
  195. auto derivedType = getTypeInfo(inputPtr);
  196. if(baseType == *derivedType)
  197. return (void*)inputPtr;
  198. return boost::any_cast<void*>(castHelper<&IPointerCaster::castRawPtr>((void*)inputPtr, &baseType, derivedType));
  199. }
  200. template<typename TInput>
  201. boost::any castSharedToMostDerived(const std::shared_ptr<TInput> inputPtr)
  202. {
  203. auto &baseType = typeid(typename std::remove_cv<TInput>::type);
  204. auto derivedType = getTypeInfo(inputPtr.get());
  205. if(baseType == *derivedType)
  206. return inputPtr;
  207. return castHelper<&IPointerCaster::castSharedPtr>(inputPtr, &baseType, derivedType);
  208. }
  209. void* castRaw(void *inputPtr, const std::type_info *from, const std::type_info *to)
  210. {
  211. return boost::any_cast<void*>(castHelper<&IPointerCaster::castRawPtr>(inputPtr, from, to));
  212. }
  213. boost::any castShared(boost::any inputPtr, const std::type_info *from, const std::type_info *to)
  214. {
  215. return castHelper<&IPointerCaster::castSharedPtr>(inputPtr, from, to);
  216. }
  217. template <typename T> const std::type_info * getTypeInfo(const T * t = nullptr)
  218. {
  219. if(t)
  220. return &typeid(*t);
  221. else
  222. return &typeid(T);
  223. }
  224. };
  225. extern DLL_LINKAGE CTypeList typeList;
  226. template<typename Variant, typename Source>
  227. struct VariantLoaderHelper
  228. {
  229. Source & source;
  230. std::vector<std::function<Variant()>> funcs;
  231. VariantLoaderHelper(Source & source):
  232. source(source)
  233. {
  234. mpl::for_each<typename Variant::types>(std::ref(*this));
  235. }
  236. template<typename Type>
  237. void operator()(Type)
  238. {
  239. funcs.push_back([&]() -> Variant
  240. {
  241. Type obj;
  242. source >> obj;
  243. return Variant(obj);
  244. });
  245. }
  246. };
  247. template<typename T>
  248. struct SerializationLevel
  249. {
  250. typedef mpl::integral_c_tag tag;
  251. typedef
  252. typename mpl::eval_if<
  253. boost::is_same<T, bool>,
  254. mpl::int_<Boolean>,
  255. //else
  256. typename mpl::eval_if<
  257. boost::is_same<T, std::vector<bool> >,
  258. mpl::int_<BooleanVector>,
  259. //else
  260. typename mpl::eval_if<
  261. boost::is_fundamental<T>,
  262. mpl::int_<Primitive>,
  263. //else
  264. typename mpl::eval_if<
  265. boost::is_enum<T>,
  266. mpl::int_<Enum>,
  267. //else
  268. typename mpl::eval_if<
  269. boost::is_class<T>,
  270. mpl::int_<Serializable>,
  271. //else
  272. typename mpl::eval_if<
  273. boost::is_array<T>,
  274. mpl::int_<Array>,
  275. //else
  276. typename mpl::eval_if<
  277. boost::is_pointer<T>,
  278. mpl::int_<Pointer>,
  279. //else
  280. typename mpl::eval_if<
  281. boost::is_enum<T>,
  282. mpl::int_<Primitive>,
  283. //else
  284. mpl::int_<Wrong>
  285. >
  286. >
  287. >
  288. >
  289. >
  290. >
  291. >
  292. >::type type;
  293. static const int value = SerializationLevel::type::value;
  294. };
  295. template <typename ObjType, typename IdType>
  296. struct VectorisedObjectInfo
  297. {
  298. const std::vector<ConstTransitivePtr<ObjType> > *vector; //pointer to the appropriate vector
  299. std::function<IdType(const ObjType &)> idRetriever;
  300. //const IdType ObjType::*idPtr; //pointer to the field representing the position in the vector
  301. VectorisedObjectInfo(const std::vector< ConstTransitivePtr<ObjType> > *Vector, std::function<IdType(const ObjType &)> IdGetter)
  302. :vector(Vector), idRetriever(IdGetter)
  303. {
  304. }
  305. };
  306. template<typename T>
  307. si32 idToNumber(const T &t, typename boost::enable_if<boost::is_convertible<T,si32> >::type * dummy = 0)
  308. {
  309. return t;
  310. }
  311. template<typename T, typename NT>
  312. NT idToNumber(const BaseForID<T, NT> &t)
  313. {
  314. return t.getNum();
  315. }
  316. /// Class which is responsible for storing and loading data.
  317. class DLL_LINKAGE CSerializer
  318. {
  319. public:
  320. typedef std::map<const std::type_info *, boost::any, TypeComparer> TTypeVecMap;
  321. TTypeVecMap vectors; //entry must be a pointer to vector containing pointers to the objects of key type
  322. bool smartVectorMembersSerialization;
  323. bool sendStackInstanceByIds;
  324. CSerializer();
  325. ~CSerializer();
  326. virtual void reportState(CLogger * out){};
  327. template <typename T, typename U>
  328. void registerVectoredType(const std::vector<T*> *Vector, const std::function<U(const T&)> &idRetriever)
  329. {
  330. vectors[&typeid(T)] = VectorisedObjectInfo<T, U>(Vector, idRetriever);
  331. }
  332. template <typename T, typename U>
  333. void registerVectoredType(const std::vector<ConstTransitivePtr<T> > *Vector, const std::function<U(const T&)> &idRetriever)
  334. {
  335. vectors[&typeid(T)] = VectorisedObjectInfo<T, U>(Vector, idRetriever);
  336. }
  337. template <typename T, typename U>
  338. const VectorisedObjectInfo<T, U> *getVectorisedTypeInfo()
  339. {
  340. const std::type_info *myType = nullptr;
  341. //
  342. // if(boost::is_base_of<CGObjectInstance, T>::value) //ugly workaround to support also types derived from CGObjectInstance -> if we encounter one, treat it aas CGObj..
  343. // myType = &typeid(CGObjectInstance);
  344. // else
  345. myType = &typeid(T);
  346. TTypeVecMap::iterator i = vectors.find(myType);
  347. if(i == vectors.end())
  348. return nullptr;
  349. else
  350. {
  351. assert(!i->second.empty());
  352. assert(i->second.type() == typeid(VectorisedObjectInfo<T, U>));
  353. VectorisedObjectInfo<T, U> *ret = &(boost::any_cast<VectorisedObjectInfo<T, U>&>(i->second));
  354. return ret;
  355. }
  356. }
  357. template <typename T, typename U>
  358. T* getVectorItemFromId(const VectorisedObjectInfo<T, U> &oInfo, U id) const
  359. {
  360. /* if(id < 0)
  361. return nullptr;*/
  362. si32 idAsNumber = idToNumber(id);
  363. assert(oInfo.vector);
  364. assert(static_cast<si32>(oInfo.vector->size()) > idAsNumber);
  365. return const_cast<T*>((*oInfo.vector)[idAsNumber].get());
  366. }
  367. template <typename T, typename U>
  368. U getIdFromVectorItem(const VectorisedObjectInfo<T, U> &oInfo, const T* obj) const
  369. {
  370. if(!obj)
  371. return U(-1);
  372. return oInfo.idRetriever(*obj);
  373. }
  374. void addStdVecItems(CGameState *gs, LibClasses *lib = VLC);
  375. };
  376. class IBinaryWriter : public virtual CSerializer
  377. {
  378. public:
  379. virtual int write(const void * data, unsigned size) = 0;
  380. };
  381. class DLL_LINKAGE CSaverBase
  382. {
  383. protected:
  384. IBinaryWriter * writer;
  385. public:
  386. CSaverBase(IBinaryWriter * w): writer(w){};
  387. inline int write(const void * data, unsigned size)
  388. {
  389. return writer->write(data, size);
  390. };
  391. };
  392. class CBasicPointerSaver
  393. {
  394. public:
  395. virtual void savePtr(CSaverBase &ar, const void *data) const =0;
  396. virtual ~CBasicPointerSaver(){}
  397. };
  398. template <typename T> //metafunction returning CGObjectInstance if T is its derivate or T elsewise
  399. struct VectorisedTypeFor
  400. {
  401. typedef typename
  402. //if
  403. mpl::eval_if<boost::is_same<CGHeroInstance,T>,
  404. mpl::identity<CGHeroInstance>,
  405. //else if
  406. mpl::eval_if<boost::is_base_of<CGObjectInstance,T>,
  407. mpl::identity<CGObjectInstance>,
  408. //else
  409. mpl::identity<T>
  410. > >::type type;
  411. };
  412. template <typename U>
  413. struct VectorizedIDType
  414. {
  415. typedef typename
  416. //if
  417. mpl::eval_if<boost::is_same<CArtifact,U>,
  418. mpl::identity<ArtifactID>,
  419. //else if
  420. mpl::eval_if<boost::is_same<CCreature,U>,
  421. mpl::identity<CreatureID>,
  422. //else if
  423. mpl::eval_if<boost::is_same<CHero,U>,
  424. mpl::identity<HeroTypeID>,
  425. //else if
  426. mpl::eval_if<boost::is_same<CArtifactInstance,U>,
  427. mpl::identity<ArtifactInstanceID>,
  428. //else if
  429. mpl::eval_if<boost::is_same<CGHeroInstance,U>,
  430. mpl::identity<HeroTypeID>,
  431. //else if
  432. mpl::eval_if<boost::is_base_of<CGObjectInstance,U>,
  433. mpl::identity<ObjectInstanceID>,
  434. //else
  435. mpl::identity<si32>
  436. > > > > > >::type type;
  437. };
  438. template <typename Handler>
  439. struct VariantVisitorSaver : boost::static_visitor<>
  440. {
  441. Handler &h;
  442. VariantVisitorSaver(Handler &H):h(H)
  443. {
  444. }
  445. template <typename T>
  446. void operator()(const T &t)
  447. {
  448. h << t;
  449. }
  450. };
  451. template<typename Ser,typename T>
  452. struct SaveIfStackInstance
  453. {
  454. static bool invoke(Ser &s, const T &data)
  455. {
  456. return false;
  457. }
  458. };
  459. template<typename Ser>
  460. struct SaveIfStackInstance<Ser, CStackInstance *>
  461. {
  462. static bool invoke(Ser &s, const CStackInstance* const &data)
  463. {
  464. assert(data->armyObj);
  465. SlotID slot;
  466. if(data->getNodeType() == CBonusSystemNode::COMMANDER)
  467. slot = SlotID::COMMANDER_SLOT_PLACEHOLDER;
  468. else
  469. slot = data->armyObj->findStack(data);
  470. assert(slot != SlotID());
  471. s << data->armyObj << slot;
  472. return true;
  473. }
  474. };
  475. template<typename Ser,typename T>
  476. struct LoadIfStackInstance
  477. {
  478. static bool invoke(Ser &s, T &data)
  479. {
  480. return false;
  481. }
  482. };
  483. template<typename Ser>
  484. struct LoadIfStackInstance<Ser, CStackInstance *>
  485. {
  486. static bool invoke(Ser &s, CStackInstance* &data)
  487. {
  488. CArmedInstance *armedObj;
  489. SlotID slot;
  490. s >> armedObj >> slot;
  491. if(slot != SlotID::COMMANDER_SLOT_PLACEHOLDER)
  492. {
  493. assert(armedObj->hasStackAtSlot(slot));
  494. data = armedObj->stacks[slot];
  495. }
  496. else
  497. {
  498. auto hero = dynamic_cast<CGHeroInstance *>(armedObj);
  499. assert(hero);
  500. assert(hero->commander);
  501. data = hero->commander;
  502. }
  503. return true;
  504. }
  505. };
  506. /// The class which manages saving objects.
  507. class DLL_LINKAGE COSer : public CSaverBase
  508. {
  509. public:
  510. struct SaveBoolean
  511. {
  512. static void invoke(COSer &s, const bool &data)
  513. {
  514. s.saveBoolean(data);
  515. }
  516. };
  517. struct SaveBooleanVector
  518. {
  519. static void invoke(COSer &s, const std::vector<bool> &data)
  520. {
  521. s.saveBooleanVector(data);
  522. }
  523. };
  524. template<typename T>
  525. struct SavePrimitive
  526. {
  527. static void invoke(COSer &s, const T &data)
  528. {
  529. s.savePrimitive(data);
  530. }
  531. };
  532. template<typename T>
  533. struct SaveSerializable
  534. {
  535. static void invoke(COSer &s, const T &data)
  536. {
  537. s.saveSerializable(data);
  538. }
  539. };
  540. template<typename T>
  541. struct SaveEnum
  542. {
  543. static void invoke(COSer &s, const T &data)
  544. {
  545. s.saveEnum(data);
  546. }
  547. };
  548. template<typename T>
  549. struct SavePointer
  550. {
  551. static void invoke(COSer &s, const T &data)
  552. {
  553. s.savePointer(data);
  554. }
  555. };
  556. template<typename T>
  557. struct SaveArray
  558. {
  559. static void invoke(COSer &s, const T &data)
  560. {
  561. s.saveArray(data);
  562. }
  563. };
  564. template<typename T>
  565. struct SaveWrong
  566. {
  567. static void invoke(COSer &s, const T &data)
  568. {
  569. throw std::runtime_error("Wrong save serialization call!");
  570. }
  571. };
  572. template <typename T>
  573. class CPointerSaver : public CBasicPointerSaver
  574. {
  575. public:
  576. void savePtr(CSaverBase &ar, const void *data) const override
  577. {
  578. COSer &s = static_cast<COSer&>(ar);
  579. const T *ptr = static_cast<const T*>(data);
  580. //T is most derived known type, it's time to call actual serialize
  581. const_cast<T&>(*ptr).serialize(s,version);
  582. }
  583. };
  584. bool saving;
  585. std::map<ui16,CBasicPointerSaver*> savers; // typeID => CPointerSaver<serializer,type>
  586. std::map<const void*, ui32> savedPointers;
  587. bool smartPointerSerialization;
  588. COSer(IBinaryWriter * w): CSaverBase(w)
  589. {
  590. saving=true;
  591. smartPointerSerialization = true;
  592. }
  593. ~COSer()
  594. {
  595. std::map<ui16,CBasicPointerSaver*>::iterator iter;
  596. for(iter = savers.begin(); iter != savers.end(); iter++)
  597. delete iter->second;
  598. }
  599. template<typename T>
  600. void addSaver(const T * t = nullptr)
  601. {
  602. auto ID = typeList.getTypeID(t);
  603. if(!savers.count(ID))
  604. savers[ID] = new CPointerSaver<T>;
  605. }
  606. template<typename Base, typename Derived> void registerType(const Base * b = nullptr, const Derived * d = nullptr)
  607. {
  608. typeList.registerType(b, d);
  609. addSaver(b);
  610. addSaver(d);
  611. }
  612. template<class T>
  613. COSer & operator<<(const T &t)
  614. {
  615. this->save(t);
  616. return * this;
  617. }
  618. template<class T>
  619. COSer & operator&(const T & t)
  620. {
  621. return * this << t;
  622. }
  623. template <typename T>
  624. void savePrimitive(const T &data)
  625. {
  626. this->write(&data,sizeof(data));
  627. }
  628. template <typename T>
  629. void savePointer(const T &data)
  630. {
  631. //write if pointer is not nullptr
  632. ui8 hlp = (data!=nullptr);
  633. *this << hlp;
  634. //if pointer is nullptr then we don't need anything more...
  635. if(!hlp)
  636. return;
  637. if(writer->smartVectorMembersSerialization)
  638. {
  639. typedef typename boost::remove_const<typename boost::remove_pointer<T>::type>::type TObjectType;
  640. typedef typename VectorisedTypeFor<TObjectType>::type VType;
  641. typedef typename VectorizedIDType<TObjectType>::type IDType;
  642. if(const auto *info = writer->getVectorisedTypeInfo<VType, IDType>())
  643. {
  644. IDType id = writer->getIdFromVectorItem<VType>(*info, data);
  645. *this << id;
  646. if(id != IDType(-1)) //vector id is enough
  647. return;
  648. }
  649. }
  650. if(writer->sendStackInstanceByIds)
  651. {
  652. const bool gotSaved = SaveIfStackInstance<COSer,T>::invoke(*this, data);
  653. if(gotSaved)
  654. return;
  655. }
  656. if(smartPointerSerialization)
  657. {
  658. // We might have an object that has multiple inheritance and store it via the non-first base pointer.
  659. // Therefore, all pointers need to be normalized to the actual object address.
  660. auto actualPointer = typeList.castToMostDerived(data);
  661. std::map<const void*,ui32>::iterator i = savedPointers.find(actualPointer);
  662. if(i != savedPointers.end())
  663. {
  664. //this pointer has been already serialized - write only it's id
  665. *this << i->second;
  666. return;
  667. }
  668. //give id to this pointer
  669. ui32 pid = (ui32)savedPointers.size();
  670. savedPointers[actualPointer] = pid;
  671. *this << pid;
  672. }
  673. //write type identifier
  674. ui16 tid = typeList.getTypeID(data);
  675. *this << tid;
  676. this->savePointerHlp(tid, data);
  677. }
  678. //that part of ptr serialization was extracted to allow customization of its behavior in derived classes
  679. template <typename T>
  680. void savePointerHlp(ui16 tid, const T &data)
  681. {
  682. if(!tid)
  683. *this << *data; //if type is unregistered simply write all data in a standard way
  684. else
  685. savers[tid]->savePtr(*this, typeList.castToMostDerived(data)); //call serializer specific for our real type
  686. }
  687. template <typename T>
  688. void saveArray(const T &data)
  689. {
  690. ui32 size = ARRAY_COUNT(data);
  691. for(ui32 i=0; i < size; i++)
  692. *this << data[i];
  693. }
  694. template <typename T>
  695. void save(const T &data)
  696. {
  697. typedef
  698. //if
  699. typename mpl::eval_if< mpl::equal_to<SerializationLevel<T>,mpl::int_<Boolean> >,
  700. mpl::identity<SaveBoolean>,
  701. //else if
  702. typename mpl::eval_if< mpl::equal_to<SerializationLevel<T>,mpl::int_<BooleanVector> >,
  703. mpl::identity<SaveBooleanVector>,
  704. //else if
  705. typename mpl::eval_if< mpl::equal_to<SerializationLevel<T>,mpl::int_<Primitive> >,
  706. mpl::identity<SavePrimitive<T> >,
  707. //else if
  708. typename mpl::eval_if<mpl::equal_to<SerializationLevel<T>,mpl::int_<Enum> >,
  709. mpl::identity<SaveEnum<T> >,
  710. //else if
  711. typename mpl::eval_if<mpl::equal_to<SerializationLevel<T>,mpl::int_<Pointer> >,
  712. mpl::identity<SavePointer<T> >,
  713. //else if
  714. typename mpl::eval_if<mpl::equal_to<SerializationLevel<T>,mpl::int_<Array> >,
  715. mpl::identity<SaveArray<T> >,
  716. //else if
  717. typename mpl::eval_if<mpl::equal_to<SerializationLevel<T>,mpl::int_<Serializable> >,
  718. mpl::identity<SaveSerializable<T> >,
  719. //else
  720. mpl::identity<SaveWrong<T> >
  721. >
  722. >
  723. >
  724. >
  725. >
  726. >
  727. >::type typex;
  728. typex::invoke(* this, data);
  729. }
  730. template <typename T>
  731. void saveSerializable(const T &data)
  732. {
  733. const_cast<T&>(data).serialize(*this,version);
  734. }
  735. template <typename T>
  736. void saveSerializable(const shared_ptr<T> &data)
  737. {
  738. T *internalPtr = data.get();
  739. *this << internalPtr;
  740. }
  741. template <typename T>
  742. void saveSerializable(const unique_ptr<T> &data)
  743. {
  744. T *internalPtr = data.get();
  745. *this << internalPtr;
  746. }
  747. template <typename T>
  748. void saveSerializable(const std::vector<T> &data)
  749. {
  750. ui32 length = data.size();
  751. *this << length;
  752. for(ui32 i=0;i<length;i++)
  753. *this << data[i];
  754. }
  755. template <typename T, size_t N>
  756. void saveSerializable(const std::array<T, N> &data)
  757. {
  758. for(ui32 i=0; i < N; i++)
  759. *this << data[i];
  760. }
  761. template <typename T>
  762. void saveSerializable(const std::set<T> &data)
  763. {
  764. std::set<T> &d = const_cast<std::set<T> &>(data);
  765. ui32 length = d.size();
  766. *this << length;
  767. for(typename std::set<T>::iterator i=d.begin();i!=d.end();i++)
  768. *this << *i;
  769. }
  770. template <typename T, typename U>
  771. void saveSerializable(const std::unordered_set<T, U> &data)
  772. {
  773. std::unordered_set<T, U> &d = const_cast<std::unordered_set<T, U> &>(data);
  774. ui32 length = d.size();
  775. *this << length;
  776. for(typename std::unordered_set<T, U>::iterator i=d.begin();i!=d.end();i++)
  777. *this << *i;
  778. }
  779. template <typename T>
  780. void saveSerializable(const std::list<T> &data)
  781. {
  782. std::list<T> &d = const_cast<std::list<T> &>(data);
  783. ui32 length = d.size();
  784. *this << length;
  785. for(typename std::list<T>::iterator i=d.begin();i!=d.end();i++)
  786. *this << *i;
  787. }
  788. void saveSerializable(const std::string &data)
  789. {
  790. *this << ui32(data.length());
  791. this->write(data.c_str(),data.size());
  792. }
  793. template <typename T1, typename T2>
  794. void saveSerializable(const std::pair<T1,T2> &data)
  795. {
  796. *this << data.first << data.second;
  797. }
  798. template <typename T1, typename T2>
  799. void saveSerializable(const std::map<T1,T2> &data)
  800. {
  801. *this << ui32(data.size());
  802. for(typename std::map<T1,T2>::const_iterator i=data.begin();i!=data.end();i++)
  803. *this << i->first << i->second;
  804. }
  805. template <typename T1, typename T2>
  806. void saveSerializable(const std::multimap<T1, T2> &data)
  807. {
  808. *this << ui32(data.size());
  809. for(typename std::map<T1, T2>::const_iterator i = data.begin(); i != data.end(); i++)
  810. *this << i->first << i->second;
  811. }
  812. template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
  813. void saveSerializable(const boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> &data)
  814. {
  815. si32 which = data.which();
  816. *this << which;
  817. VariantVisitorSaver<COSer> visitor(*this);
  818. boost::apply_visitor(visitor, data);
  819. }
  820. template <typename T>
  821. void saveSerializable(const boost::optional<T> &data)
  822. {
  823. if(data)
  824. {
  825. *this << (ui8)1;
  826. *this << *data;
  827. }
  828. else
  829. {
  830. *this << (ui8)0;
  831. }
  832. }
  833. template <typename E>
  834. void saveEnum(const E &data)
  835. {
  836. si32 writ = static_cast<si32>(data);
  837. *this << writ;
  838. }
  839. void saveBoolean(const bool & data)
  840. {
  841. ui8 writ = static_cast<ui8>(data);
  842. *this << writ;
  843. }
  844. void saveBooleanVector(const std::vector<bool> & data)
  845. {
  846. std::vector<ui8> convData;
  847. std::copy(data.begin(), data.end(), std::back_inserter(convData));
  848. saveSerializable(convData);
  849. }
  850. };
  851. class IBinaryReader : public virtual CSerializer
  852. {
  853. public:
  854. virtual int read(void * data, unsigned size) = 0;
  855. };
  856. class DLL_LINKAGE CLoaderBase
  857. {
  858. protected:
  859. IBinaryReader * reader;
  860. public:
  861. CLoaderBase(IBinaryReader * r): reader(r){};
  862. inline int read(void * data, unsigned size)
  863. {
  864. return reader->read(data, size);
  865. };
  866. };
  867. class CBasicPointerLoader
  868. {
  869. public:
  870. virtual const std::type_info * loadPtr(CLoaderBase &ar, void *data, ui32 pid) const =0; //data is pointer to the ACTUAL POINTER
  871. virtual ~CBasicPointerLoader(){}
  872. };
  873. template <typename T, typename Enable = void>
  874. struct ClassObjectCreator
  875. {
  876. static T *invoke()
  877. {
  878. static_assert(!std::is_abstract<T>::value, "Cannot call new upon abstract classes!");
  879. return new T();
  880. }
  881. };
  882. template<typename T>
  883. struct ClassObjectCreator<T, typename std::enable_if<std::is_abstract<T>::value>::type>
  884. {
  885. static T *invoke()
  886. {
  887. throw std::runtime_error("Something went really wrong during deserialization. Attempted creating an object of an abstract class " + std::string(typeid(T).name()));
  888. }
  889. };
  890. /// The class which manages loading of objects.
  891. class DLL_LINKAGE CISer : public CLoaderBase
  892. {
  893. public:
  894. struct LoadBoolean
  895. {
  896. static void invoke(CISer &s, bool &data)
  897. {
  898. s.loadBoolean(data);
  899. }
  900. };
  901. struct LoadBooleanVector
  902. {
  903. static void invoke(CISer &s, std::vector<bool> &data)
  904. {
  905. s.loadBooleanVector(data);
  906. }
  907. };
  908. template<typename T>
  909. struct LoadEnum
  910. {
  911. static void invoke(CISer &s, T &data)
  912. {
  913. s.loadEnum(data);
  914. }
  915. };
  916. template<typename T>
  917. struct LoadPrimitive
  918. {
  919. static void invoke(CISer &s, T &data)
  920. {
  921. s.loadPrimitive(data);
  922. }
  923. };
  924. template<typename T>
  925. struct LoadPointer
  926. {
  927. static void invoke(CISer &s, T &data)
  928. {
  929. s.loadPointer(data);
  930. }
  931. };
  932. template<typename T>
  933. struct LoadArray
  934. {
  935. static void invoke(CISer &s, T &data)
  936. {
  937. s.loadArray(data);
  938. }
  939. };
  940. template<typename T>
  941. struct LoadSerializable
  942. {
  943. static void invoke(CISer &s, T &data)
  944. {
  945. s.loadSerializable(data);
  946. }
  947. };
  948. template<typename T>
  949. struct LoadWrong
  950. {
  951. static void invoke(CISer &s, const T &data)
  952. {
  953. throw std::runtime_error("Wrong load serialization call!");
  954. }
  955. };
  956. template <typename T> class CPointerLoader : public CBasicPointerLoader
  957. {
  958. public:
  959. const std::type_info * loadPtr(CLoaderBase &ar, void *data, ui32 pid) const override //data is pointer to the ACTUAL POINTER
  960. {
  961. CISer &s = static_cast<CISer&>(ar);
  962. T *&ptr = *static_cast<T**>(data);
  963. //create new object under pointer
  964. typedef typename boost::remove_pointer<T>::type npT;
  965. ptr = ClassObjectCreator<npT>::invoke(); //does new npT or throws for abstract classes
  966. s.ptrAllocated(ptr, pid);
  967. //T is most derived known type, it's time to call actual serialize
  968. ptr->serialize(s,version);
  969. return &typeid(T);
  970. }
  971. };
  972. bool saving;
  973. std::map<ui16,CBasicPointerLoader*> loaders; // typeID => CPointerSaver<serializer,type>
  974. si32 fileVersion;
  975. bool reverseEndianess; //if source has different endianness than us, we reverse bytes
  976. std::map<ui32, void*> loadedPointers;
  977. std::map<ui32, const std::type_info*> loadedPointersTypes;
  978. std::map<const void*, boost::any> loadedSharedPointers;
  979. bool smartPointerSerialization;
  980. CISer(IBinaryReader * r): CLoaderBase(r)
  981. {
  982. saving = false;
  983. fileVersion = 0;
  984. smartPointerSerialization = true;
  985. reverseEndianess = false;
  986. }
  987. ~CISer()
  988. {
  989. std::map<ui16,CBasicPointerLoader*>::iterator iter;
  990. for(iter = loaders.begin(); iter != loaders.end(); iter++)
  991. delete iter->second;
  992. }
  993. template<typename T>
  994. void addLoader(const T * t = nullptr)
  995. {
  996. auto ID = typeList.getTypeID(t);
  997. if(!loaders.count(ID))
  998. loaders[ID] = new CPointerLoader<T>;
  999. }
  1000. template<typename Base, typename Derived> void registerType(const Base * b = nullptr, const Derived * d = nullptr)
  1001. {
  1002. typeList.registerType(b, d);
  1003. addLoader(b);
  1004. addLoader(d);
  1005. }
  1006. template<class T>
  1007. CISer & operator>>(T &t)
  1008. {
  1009. this->load(t);
  1010. return * this;
  1011. }
  1012. template<class T>
  1013. CISer & operator&(T & t)
  1014. {
  1015. return * this >> t;
  1016. }
  1017. int write(const void * data, unsigned size);
  1018. template <typename T>
  1019. void load(T &data)
  1020. {
  1021. typedef
  1022. //if
  1023. typename mpl::eval_if< mpl::equal_to<SerializationLevel<T>,mpl::int_<Boolean> >,
  1024. mpl::identity<LoadBoolean>,
  1025. //else if
  1026. typename mpl::eval_if< mpl::equal_to<SerializationLevel<T>,mpl::int_<BooleanVector> >,
  1027. mpl::identity<LoadBooleanVector>,
  1028. //else if
  1029. typename mpl::eval_if< mpl::equal_to<SerializationLevel<T>,mpl::int_<Primitive> >,
  1030. mpl::identity<LoadPrimitive<T> >,
  1031. //else if
  1032. typename mpl::eval_if<mpl::equal_to<SerializationLevel<T>,mpl::int_<Enum> >,
  1033. mpl::identity<LoadEnum<T> >,
  1034. //else if
  1035. typename mpl::eval_if<mpl::equal_to<SerializationLevel<T>,mpl::int_<Pointer> >,
  1036. mpl::identity<LoadPointer<T> >,
  1037. //else if
  1038. typename mpl::eval_if<mpl::equal_to<SerializationLevel<T>,mpl::int_<Array> >,
  1039. mpl::identity<LoadArray<T> >,
  1040. //else if
  1041. typename mpl::eval_if<mpl::equal_to<SerializationLevel<T>,mpl::int_<Serializable> >,
  1042. mpl::identity<LoadSerializable<T> >,
  1043. //else
  1044. mpl::identity<LoadWrong<T> >
  1045. >
  1046. >
  1047. >
  1048. >
  1049. >
  1050. >
  1051. >::type typex;
  1052. typex::invoke(* this, data);
  1053. }
  1054. template <typename T>
  1055. void loadPrimitive(T &data)
  1056. {
  1057. if(0) //for testing #989
  1058. {
  1059. this->read(&data,sizeof(data));
  1060. }
  1061. else
  1062. {
  1063. unsigned length = sizeof(data);
  1064. char* dataPtr = (char*)&data;
  1065. this->read(dataPtr,length);
  1066. if(reverseEndianess)
  1067. std::reverse(dataPtr, dataPtr + length);
  1068. }
  1069. }
  1070. template <typename T>
  1071. void loadSerializableBySerializeCall(T &data)
  1072. {
  1073. ////that const cast is evil because it allows to implicitly overwrite const objects when deserializing
  1074. typedef typename boost::remove_const<T>::type nonConstT;
  1075. nonConstT &hlp = const_cast<nonConstT&>(data);
  1076. hlp.serialize(*this,fileVersion);
  1077. //data.serialize(*this,myVersion);
  1078. }
  1079. template <typename T>
  1080. void loadSerializable(T &data)
  1081. {
  1082. loadSerializableBySerializeCall(data);
  1083. }
  1084. template <typename T>
  1085. void loadArray(T &data)
  1086. {
  1087. ui32 size = ARRAY_COUNT(data);
  1088. for(ui32 i = 0; i < size; i++)
  1089. *this >> data[i];
  1090. }
  1091. template <typename T>
  1092. void loadPointer(T &data)
  1093. {
  1094. ui8 hlp;
  1095. *this >> hlp;
  1096. if(!hlp)
  1097. {
  1098. data = nullptr;
  1099. return;
  1100. }
  1101. if(reader->smartVectorMembersSerialization)
  1102. {
  1103. typedef typename boost::remove_const<typename boost::remove_pointer<T>::type>::type TObjectType; //eg: const CGHeroInstance * => CGHeroInstance
  1104. typedef typename VectorisedTypeFor<TObjectType>::type VType; //eg: CGHeroInstance -> CGobjectInstance
  1105. typedef typename VectorizedIDType<TObjectType>::type IDType;
  1106. if(const auto *info = reader->getVectorisedTypeInfo<VType, IDType>())
  1107. {
  1108. IDType id;
  1109. *this >> id;
  1110. if(id != IDType(-1))
  1111. {
  1112. data = static_cast<T>(reader->getVectorItemFromId<VType, IDType>(*info, id));
  1113. return;
  1114. }
  1115. }
  1116. }
  1117. if(reader->sendStackInstanceByIds)
  1118. {
  1119. bool gotLoaded = LoadIfStackInstance<CISer,T>::invoke(* this, data);
  1120. if(gotLoaded)
  1121. return;
  1122. }
  1123. ui32 pid = 0xffffffff; //pointer id (or maybe rather pointee id)
  1124. if(smartPointerSerialization)
  1125. {
  1126. *this >> pid; //get the id
  1127. std::map<ui32, void*>::iterator i = loadedPointers.find(pid); //lookup
  1128. if(i != loadedPointers.end())
  1129. {
  1130. // We already got this pointer
  1131. // Cast it in case we are loading it to a non-first base pointer
  1132. assert(loadedPointersTypes.count(pid));
  1133. data = reinterpret_cast<T>(typeList.castRaw(i->second, loadedPointersTypes.at(pid), &typeid(typename boost::remove_const<typename boost::remove_pointer<T>::type>::type)));
  1134. return;
  1135. }
  1136. }
  1137. //get type id
  1138. ui16 tid;
  1139. *this >> tid;
  1140. this->loadPointerHlp(tid, data, pid);
  1141. }
  1142. //that part of ptr deserialization was extracted to allow customization of its behavior in derived classes
  1143. template <typename T>
  1144. void loadPointerHlp( ui16 tid, T & data, ui32 pid )
  1145. {
  1146. if(!tid)
  1147. {
  1148. typedef typename boost::remove_pointer<T>::type npT;
  1149. typedef typename boost::remove_const<npT>::type ncpT;
  1150. data = ClassObjectCreator<ncpT>::invoke();
  1151. ptrAllocated(data, pid);
  1152. *this >> *data;
  1153. }
  1154. else
  1155. {
  1156. auto typeInfo = loaders[tid]->loadPtr(*this,&data, pid);
  1157. data = reinterpret_cast<T>(typeList.castRaw((void*)data, typeInfo, &typeid(typename boost::remove_const<typename boost::remove_pointer<T>::type>::type)));
  1158. }
  1159. }
  1160. template <typename T>
  1161. void ptrAllocated(const T *ptr, ui32 pid)
  1162. {
  1163. if(smartPointerSerialization && pid != 0xffffffff)
  1164. {
  1165. loadedPointersTypes[pid] = &typeid(T);
  1166. loadedPointers[pid] = (void*)ptr; //add loaded pointer to our lookup map; cast is to avoid errors with const T* pt
  1167. }
  1168. }
  1169. #define READ_CHECK_U32(x) \
  1170. ui32 length; \
  1171. *this >> length; \
  1172. if(length > 500000) \
  1173. { \
  1174. logGlobal->warnStream() << "Warning: very big length: " << length;\
  1175. reader->reportState(logGlobal); \
  1176. };
  1177. template <typename T>
  1178. void loadSerializable(shared_ptr<T> &data)
  1179. {
  1180. typedef typename boost::remove_const<T>::type NonConstT;
  1181. NonConstT *internalPtr;
  1182. *this >> internalPtr;
  1183. void *internalPtrDerived = typeList.castToMostDerived(internalPtr);
  1184. if(internalPtr)
  1185. {
  1186. auto itr = loadedSharedPointers.find(internalPtrDerived);
  1187. if(itr != loadedSharedPointers.end())
  1188. {
  1189. // This pointers is already loaded. The "data" needs to be pointed to it,
  1190. // so their shared state is actually shared.
  1191. try
  1192. {
  1193. auto actualType = typeList.getTypeInfo(internalPtr);
  1194. auto typeWeNeedToReturn = typeList.getTypeInfo<T>();
  1195. if(*actualType == *typeWeNeedToReturn)
  1196. {
  1197. // No casting needed, just unpack already stored shared_ptr and return it
  1198. data = boost::any_cast<std::shared_ptr<T>>(itr->second);
  1199. }
  1200. else
  1201. {
  1202. // We need to perform series of casts
  1203. auto ret = typeList.castShared(itr->second, actualType, typeWeNeedToReturn);
  1204. data = boost::any_cast<std::shared_ptr<T>>(ret);
  1205. }
  1206. }
  1207. catch(std::exception &e)
  1208. {
  1209. logGlobal->errorStream() << e.what();
  1210. logGlobal->errorStream() << boost::format("Failed to cast stored shared ptr. Real type: %s. Needed type %s. FIXME FIXME FIXME")
  1211. % itr->second.type().name() % typeid(std::shared_ptr<T>).name();
  1212. //TODO scenario with inheritance -> we can have stored ptr to base and load ptr to derived (or vice versa)
  1213. assert(0);
  1214. }
  1215. }
  1216. else
  1217. {
  1218. auto hlp = std::shared_ptr<NonConstT>(internalPtr);
  1219. data = hlp; //possibly adds const
  1220. loadedSharedPointers[internalPtrDerived] = typeList.castSharedToMostDerived(hlp);
  1221. }
  1222. }
  1223. else
  1224. data.reset();
  1225. }
  1226. template <typename T>
  1227. void loadSerializable(unique_ptr<T> &data)
  1228. {
  1229. T *internalPtr;
  1230. *this >> internalPtr;
  1231. data.reset(internalPtr);
  1232. }
  1233. template <typename T>
  1234. void loadSerializable(std::vector<T> &data)
  1235. {
  1236. READ_CHECK_U32(length);
  1237. data.resize(length);
  1238. for(ui32 i=0;i<length;i++)
  1239. *this >> data[i];
  1240. }
  1241. template <typename T, size_t N>
  1242. void loadSerializable(std::array<T, N> &data)
  1243. {
  1244. for(ui32 i = 0; i < N; i++)
  1245. *this >> data[i];
  1246. }
  1247. template <typename T>
  1248. void loadSerializable(std::set<T> &data)
  1249. {
  1250. READ_CHECK_U32(length);
  1251. data.clear();
  1252. T ins;
  1253. for(ui32 i=0;i<length;i++)
  1254. {
  1255. *this >> ins;
  1256. data.insert(ins);
  1257. }
  1258. }
  1259. template <typename T, typename U>
  1260. void loadSerializable(std::unordered_set<T, U> &data)
  1261. {
  1262. READ_CHECK_U32(length);
  1263. data.clear();
  1264. T ins;
  1265. for(ui32 i=0;i<length;i++)
  1266. {
  1267. *this >> ins;
  1268. data.insert(ins);
  1269. }
  1270. }
  1271. template <typename T>
  1272. void loadSerializable(std::list<T> &data)
  1273. {
  1274. READ_CHECK_U32(length);
  1275. data.clear();
  1276. T ins;
  1277. for(ui32 i=0;i<length;i++)
  1278. {
  1279. *this >> ins;
  1280. data.push_back(ins);
  1281. }
  1282. }
  1283. template <typename T1, typename T2>
  1284. void loadSerializable(std::pair<T1,T2> &data)
  1285. {
  1286. *this >> data.first >> data.second;
  1287. }
  1288. template <typename T1, typename T2>
  1289. void loadSerializable(std::map<T1,T2> &data)
  1290. {
  1291. READ_CHECK_U32(length);
  1292. data.clear();
  1293. T1 key;
  1294. T2 value;
  1295. for(ui32 i=0;i<length;i++)
  1296. {
  1297. *this >> key >> value;
  1298. data.insert(std::pair<T1, T2>(std::move(key), std::move(value)));
  1299. }
  1300. }
  1301. template <typename T1, typename T2>
  1302. void loadSerializable(std::multimap<T1, T2> &data)
  1303. {
  1304. READ_CHECK_U32(length);
  1305. data.clear();
  1306. T1 key;
  1307. T2 value;
  1308. for(ui32 i = 0; i < length; i++)
  1309. {
  1310. *this >> key >> value;
  1311. data.insert(std::pair<T1, T2>(std::move(key), std::move(value)));
  1312. }
  1313. }
  1314. void loadSerializable(std::string &data)
  1315. {
  1316. READ_CHECK_U32(length);
  1317. data.resize(length);
  1318. this->read((void*)data.c_str(),length);
  1319. }
  1320. template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
  1321. void loadSerializable(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> &data)
  1322. {
  1323. typedef boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> TVariant;
  1324. VariantLoaderHelper<TVariant, CISer> loader(*this);
  1325. si32 which;
  1326. *this >> which;
  1327. assert(which < loader.funcs.size());
  1328. data = loader.funcs.at(which)();
  1329. }
  1330. template <typename T>
  1331. void loadSerializable(boost::optional<T> & data)
  1332. {
  1333. ui8 present;
  1334. *this >> present;
  1335. if(present)
  1336. {
  1337. T t;
  1338. *this >> t;
  1339. data = t;
  1340. }
  1341. else
  1342. {
  1343. data = boost::optional<T>();
  1344. }
  1345. }
  1346. // void loadSerializable(CStackInstance *&s)
  1347. // {
  1348. // if(sendStackInstanceByIds)
  1349. // {
  1350. // CArmedInstance *armed;
  1351. // SlotID slot;
  1352. // *this >> armed >> slot;
  1353. // assert(armed->hasStackAtSlot(slot));
  1354. // s = armed->stacks[slot];
  1355. // }
  1356. // else
  1357. // loadSerializableBySerializeCall(s);
  1358. // }
  1359. template <typename E>
  1360. void loadEnum(E &data)
  1361. {
  1362. si32 read;
  1363. *this >> read;
  1364. data = static_cast<E>(read);
  1365. }
  1366. void loadBoolean(bool &data)
  1367. {
  1368. ui8 read;
  1369. *this >> read;
  1370. data = static_cast<bool>(read);
  1371. }
  1372. void loadBooleanVector(std::vector<bool> & data)
  1373. {
  1374. std::vector<ui8> convData;
  1375. loadSerializable(convData);
  1376. convData.resize(data.size());
  1377. range::copy(convData, data.begin());
  1378. }
  1379. };
  1380. class DLL_LINKAGE CSaveFile
  1381. :public IBinaryWriter
  1382. {
  1383. public:
  1384. COSer serializer;
  1385. std::string fName;
  1386. unique_ptr<std::ofstream> sfile;
  1387. CSaveFile(const std::string &fname); //throws!
  1388. ~CSaveFile();
  1389. int write(const void * data, unsigned size) override;
  1390. void openNextFile(const std::string &fname); //throws!
  1391. void clear();
  1392. void reportState(CLogger * out) override;
  1393. void putMagicBytes(const std::string &text);
  1394. template<class T>
  1395. CSaveFile & operator<<(const T &t)
  1396. {
  1397. serializer << t;
  1398. return * this;
  1399. }
  1400. };
  1401. class DLL_LINKAGE CLoadFile
  1402. : public IBinaryReader
  1403. {
  1404. public:
  1405. CISer serializer;
  1406. std::string fName;
  1407. unique_ptr<boost::filesystem::ifstream> sfile;
  1408. CLoadFile(const boost::filesystem::path & fname, int minimalVersion = version); //throws!
  1409. ~CLoadFile();
  1410. int read(void * data, unsigned size) override; //throws!
  1411. void openNextFile(const boost::filesystem::path & fname, int minimalVersion); //throws!
  1412. void clear();
  1413. void reportState(CLogger * out) override;
  1414. void checkMagicBytes(const std::string & text);
  1415. template<class T>
  1416. CLoadFile & operator>>(T &t)
  1417. {
  1418. serializer >> t;
  1419. return * this;
  1420. }
  1421. };
  1422. class DLL_LINKAGE CLoadIntegrityValidator
  1423. : public IBinaryReader
  1424. {
  1425. public:
  1426. CISer serializer;
  1427. unique_ptr<CLoadFile> primaryFile, controlFile;
  1428. bool foundDesync;
  1429. CLoadIntegrityValidator(const std::string &primaryFileName, const std::string &controlFileName, int minimalVersion = version); //throws!
  1430. int read( void * data, unsigned size) override; //throws!
  1431. void checkMagicBytes(const std::string &text);
  1432. unique_ptr<CLoadFile> decay(); //returns primary file. CLoadIntegrityValidator stops being usable anymore
  1433. };
  1434. typedef boost::asio::basic_stream_socket < boost::asio::ip::tcp , boost::asio::stream_socket_service<boost::asio::ip::tcp> > TSocket;
  1435. typedef boost::asio::basic_socket_acceptor<boost::asio::ip::tcp, boost::asio::socket_acceptor_service<boost::asio::ip::tcp> > TAcceptor;
  1436. class DLL_LINKAGE CConnection
  1437. : public IBinaryReader, public IBinaryWriter
  1438. {
  1439. //CGameState *gs;
  1440. CConnection(void);
  1441. void init();
  1442. void reportState(CLogger * out) override;
  1443. public:
  1444. CISer iser;
  1445. COSer oser;
  1446. boost::mutex *rmx, *wmx; // read/write mutexes
  1447. TSocket * socket;
  1448. bool logging;
  1449. bool connected;
  1450. bool myEndianess, contactEndianess; //true if little endian, if endianness is different we'll have to revert received multi-byte vars
  1451. boost::asio::io_service *io_service;
  1452. std::string name; //who uses this connection
  1453. int connectionID;
  1454. boost::thread *handler;
  1455. bool receivedStop, sendStop;
  1456. CConnection(std::string host, std::string port, std::string Name);
  1457. CConnection(TAcceptor * acceptor, boost::asio::io_service *Io_service, std::string Name);
  1458. CConnection(TSocket * Socket, std::string Name); //use immediately after accepting connection into socket
  1459. int write(const void * data, unsigned size) override;
  1460. int read(void * data, unsigned size) override;
  1461. void close();
  1462. bool isOpen() const;
  1463. template<class T>
  1464. CConnection &operator&(const T&);
  1465. virtual ~CConnection(void);
  1466. CPack *retreivePack(); //gets from server next pack (allocates it with new)
  1467. void sendPackToServer(const CPack &pack, PlayerColor player, ui32 requestID);
  1468. void disableStackSendingByID();
  1469. void enableStackSendingByID();
  1470. void disableSmartPointerSerialization();
  1471. void enableSmartPointerSerializatoin();
  1472. void disableSmartVectorMemberSerialization();
  1473. void enableSmartVectorMemberSerializatoin();
  1474. void prepareForSendingHeroes(); //disables sending vectorised, enables smart pointer serialization, clears saved/loaded ptr cache
  1475. void enterPregameConnectionMode();
  1476. template<class T>
  1477. CConnection & operator>>(T &t)
  1478. {
  1479. iser >> t;
  1480. return * this;
  1481. }
  1482. template<class T>
  1483. CConnection & operator<<(const T &t)
  1484. {
  1485. oser << t;
  1486. return * this;
  1487. }
  1488. };
  1489. DLL_LINKAGE std::ostream &operator<<(std::ostream &str, const CConnection &cpc);
  1490. // Serializer that stores objects in the dynamic buffer. Allows performing deep object copies.
  1491. class DLL_LINKAGE CMemorySerializer
  1492. : public IBinaryReader, public IBinaryWriter
  1493. {
  1494. std::vector<ui8> buffer;
  1495. size_t readPos; //index of the next byte to be read
  1496. public:
  1497. CISer iser;
  1498. COSer oser;
  1499. int read(void * data, unsigned size) override; //throws!
  1500. int write(const void * data, unsigned size) override;
  1501. CMemorySerializer();
  1502. template <typename T>
  1503. static unique_ptr<T> deepCopy(const T &data)
  1504. {
  1505. CMemorySerializer mem;
  1506. mem.oser << &data;
  1507. unique_ptr<T> ret;
  1508. mem.iser >> ret;
  1509. return ret;
  1510. }
  1511. };
  1512. template<typename T>
  1513. class CApplier
  1514. {
  1515. public:
  1516. std::map<ui16,T*> apps;
  1517. ~CApplier()
  1518. {
  1519. typename std::map<ui16, T*>::iterator iter;
  1520. for(iter = apps.begin(); iter != apps.end(); iter++)
  1521. delete iter->second;
  1522. }
  1523. template<typename RegisteredType>
  1524. void addApplier(ui16 ID)
  1525. {
  1526. if(!apps.count(ID))
  1527. {
  1528. RegisteredType * rtype = nullptr;
  1529. apps[ID] = T::getApplier(rtype);
  1530. }
  1531. }
  1532. template<typename Base, typename Derived>
  1533. void registerType(const Base * b = nullptr, const Derived * d = nullptr)
  1534. {
  1535. typeList.registerType(b, d);
  1536. addApplier<Base>(typeList.getTypeID(b));
  1537. addApplier<Derived>(typeList.getTypeID(d));
  1538. }
  1539. };