LCOV - code coverage report
Current view: top level - shared - Serialization.cpp (source / functions) Hit Total Coverage
Test: code-coverage.info.cleaned Lines: 143 148 96.6 %
Date: 2023-01-28 00:08:57 Functions: 24 25 96.0 %

          Line data    Source code
       1             : #include <shared.hpp>
       2             : #include <boost/serialization/shared_ptr.hpp>
       3             : #include <boost/serialization/split_member.hpp>
       4             : #include <boost/serialization/array.hpp>
       5             : #include <boost/serialization/variant.hpp>
       6             : #include <algorithm>
       7             : #include <iostream>
       8             : 
       9             : using namespace shared;
      10             : 
      11             : typedef std::variant<Caravan, Barbarian, BarbarianVillage, ControlPawn, City> elementVariant;
      12             : 
      13             : template <class Archive>
      14           6 : void Map::serialize(Archive &ar, const unsigned int version)
      15             : {
      16           6 :     boost::serialization::split_member(ar, *this, version);
      17           6 : }
      18             : 
      19             : template <class Archive>
      20           3 : void Map::save(Archive &ar, const unsigned int version) const
      21             : {
      22           3 :     ar << height;
      23           3 :     ar << width;
      24           3 :     ar << mapOfTheGame;
      25           3 : }
      26             : 
      27             : template <class Archive>
      28           3 : void Map::load(Archive &ar, const unsigned int version)
      29             : {
      30           3 :     ar >> height;
      31           3 :     ar >> width;
      32           3 :     isInizialize = false;
      33           3 :     this->init();
      34           3 :     ar >> mapOfTheGame;
      35           3 : }
      36             : 
      37             : template <class Archive>
      38         602 : void Hexagon::serialize(Archive &ar, const unsigned int version)
      39             : {
      40         602 :     boost::serialization::split_member(ar, *this, version);
      41         602 : }
      42             : 
      43             : template <class Archive>
      44         301 : void Hexagon::save(Archive &ar, const unsigned int version) const
      45             : {
      46         301 :     ar << level;
      47             : 
      48         301 :     std::vector<Caravan> caravans;
      49         301 :     std::vector<Barbarian> barbarians;
      50         301 :     std::vector<BarbarianVillage> barbarianVillages;
      51         301 :     std::vector<ControlPawn> controlPawns;
      52         301 :     std::vector<City> cities;
      53             : 
      54         325 :     for (const auto &element : elementsList)
      55             :     {
      56          24 :         switch (element->index())
      57             :         {
      58           0 :         case 0:
      59           0 :             caravans.push_back(std::get<Caravan>(*element));
      60           0 :             break;
      61           6 :         case 1:
      62           6 :             barbarians.push_back(std::get<Barbarian>(*element));
      63           6 :             break;
      64           6 :         case 2:
      65           6 :             barbarianVillages.push_back(std::get<BarbarianVillage>(*element));
      66           6 :             break;
      67           1 :         case 3:
      68           1 :             controlPawns.push_back(std::get<ControlPawn>(*element));
      69           1 :             break;
      70          11 :         case 4:
      71          11 :             cities.push_back(std::get<City>(*element));
      72          11 :             break;
      73             :         }
      74             :     }
      75         301 :     ar << caravans.size();
      76         301 :     ar << barbarians.size();
      77         301 :     ar << barbarianVillages.size();
      78         301 :     ar << controlPawns.size();
      79         301 :     ar << cities.size();
      80         301 :     ar << caravans;
      81         301 :     ar << barbarians;
      82         301 :     ar << barbarianVillages;
      83         301 :     ar << controlPawns;
      84         301 :     ar << cities;
      85             :     
      86         301 :     bool haveResource = (hexResource != nullptr);
      87         301 :     ar << haveResource;
      88         301 :     if (haveResource)
      89             :     {
      90          15 :         bool alive = hexResource->isAlive;
      91          15 :         int type = (int) hexResource->type;
      92          15 :         ar << alive;
      93          15 :         ar << type;
      94             :     }
      95         301 : }
      96             : 
      97             : template <class Archive>
      98         301 : void Hexagon::load(Archive &ar, const unsigned int version)
      99             : {
     100         301 :     ar >> level;
     101         301 :     size_t size = 0;
     102             : 
     103         301 :     std::vector<Caravan> caravans;
     104         301 :     std::vector<Barbarian> barbarians;
     105         301 :     std::vector<BarbarianVillage> barbarianVillages;
     106         301 :     std::vector<ControlPawn> controlPawns;
     107         301 :     std::vector<City> cities;
     108             : 
     109         301 :     ar >> size;
     110         301 :     std::generate_n(std::back_inserter(caravans), size, []()
     111           0 :                     { return Caravan(); });
     112         301 :     ar >> size;
     113         301 :     std::generate_n(std::back_inserter(barbarians), size, []()
     114           6 :                     { return Barbarian(); });
     115         301 :     ar >> size;
     116         301 :     std::generate_n(std::back_inserter(barbarianVillages), size, []()
     117           6 :                     { return BarbarianVillage(); });
     118         301 :     ar >> size;
     119         301 :     std::generate_n(std::back_inserter(controlPawns), size, []()
     120           1 :                     { return ControlPawn(); });
     121         301 :     ar >> size;
     122         301 :     std::generate_n(std::back_inserter(cities), size, []()
     123          11 :                     { return City(); });
     124             : 
     125         301 :     ar >> caravans;
     126         301 :     ar >> barbarians;
     127         301 :     ar >> barbarianVillages;
     128         301 :     ar >> controlPawns;
     129         301 :     ar >> cities;
     130             : 
     131         301 :     for (auto &caravan : caravans)
     132             :     {
     133           0 :         elementsList.push_back(std::make_shared<elementVariant>(caravan));
     134             :     }
     135         307 :     for (auto &barbarian : barbarians)
     136             :     {
     137           6 :         elementsList.push_back(std::make_shared<elementVariant>(barbarian));
     138             :     }
     139         307 :     for (auto &barbarianVillage : barbarianVillages)
     140             :     {
     141           6 :         elementsList.push_back(std::make_shared<elementVariant>(barbarianVillage));
     142             :     }
     143         302 :     for (auto &controlPawn : controlPawns)
     144             :     {
     145           1 :         elementsList.push_back(std::make_shared<elementVariant>(controlPawn));
     146             :     }
     147         312 :     for (auto &city : cities)
     148             :     {
     149          11 :         elementsList.push_back(std::make_shared<elementVariant>(city));
     150             :     }
     151             : 
     152         301 :     bool haveResource = false;
     153         301 :     ar >> haveResource;
     154         301 :     if (haveResource)
     155             :     {
     156          15 :         bool alive = false;
     157          15 :         int type = 0;
     158          15 :         ar >> alive;
     159          15 :         ar >> type;
     160          15 :         hexResource = std::make_shared<Resource>((shared::ResourceEnum) type);
     161          15 :         hexResource->isAlive = alive;
     162             :     }
     163         301 : }
     164             : 
     165             : template <class Archive>
     166           2 : void RuleArgsStruct::serialize(Archive &ar, const unsigned int version)
     167             : {
     168           2 :     ar &ruleId;
     169           2 :     ar &numberOfBoxUsed;
     170           2 :     ar &caravanMovementPath;
     171           2 :     ar &resourceToGet;
     172           2 :     ar &cardToGetABox;
     173           2 :     ar &positionToNuke;
     174           2 :     ar &pawnsPositions;
     175           2 :     ar &militaryCardAttack;
     176           2 :     ar &industryCardBuildWonder;
     177           2 :     ar &positionOfWonder;
     178           2 :     ar &positionOfCity;
     179           2 :     ar &cardsToImprove;
     180           2 :     ar &playerName;
     181           2 : }
     182             : 
     183             : template <class Archive>
     184          24 : void City::serialize(Archive &ar, const unsigned int version)
     185             : {
     186          24 :     ar &isStateCity;
     187          24 :     ar &isCapital;
     188          24 :     ar &isMature;
     189          24 :     ar &position;
     190          24 :     ar &player;
     191          24 :     int type = (int) stateCityType;
     192          24 :     ar &type;
     193          24 :     stateCityType = (shared::CityStateEnum) type;
     194          24 : }
     195             : 
     196             : template <class Archive>
     197           4 : void ControlPawn::serialize(Archive &ar, const unsigned int version)
     198             : {
     199           4 :     ar &position;
     200           4 :     ar &reinforced;
     201           4 :     ar &player;
     202           4 : }
     203             : 
     204             : template <class Archive>
     205          14 : void BarbarianVillage::serialize(Archive &ar, const unsigned int version)
     206             : {
     207             :     // serialize the related barbarian
     208          14 : }
     209             : 
     210             : template <class Archive>
     211          14 : void Barbarian::serialize(Archive &ar, const unsigned int version)
     212             : {
     213          14 :     ar &isAlive;
     214          14 : }
     215             : 
     216             : template <class Archive>
     217           2 : void Caravan::serialize(Archive &ar, const unsigned int version)
     218             : {
     219           2 :     ar &position;
     220           2 :     ar &used;
     221           2 :     ar &player;
     222           2 : }

Generated by: LCOV version 1.14