Branch data     Line data    Source code

       1                 :            : // ----------------- BEGIN LICENSE BLOCK ---------------------------------
       2                 :            : //
       3                 :            : // Copyright (C) 2018-2021 Intel Corporation
       4                 :            : //
       5                 :            : // SPDX-License-Identifier: MIT
       6                 :            : //
       7                 :            : // ----------------- END LICENSE BLOCK -----------------------------------
       8                 :            : 
       9                 :            : #include "ad/map/serialize/Serializer.hpp"
      10                 :            : #include "ad/map/access/Logging.hpp"
      11                 :            : 
      12                 :            : namespace ad {
      13                 :            : namespace map {
      14                 :            : namespace serialize {
      15                 :            : 
      16                 :            : ////////////
      17                 :            : // Constants
      18                 :            : 
      19                 :            : size_t Serializer::MAGIC = 0x03082018;
      20                 :            : size_t Serializer::VERSION_MAJOR = 0;
      21                 :            : size_t Serializer::VERSION_MINOR = 4;
      22                 :            : 
      23                 :            : /////////////////////////
      24                 :            : // Constructor/Destructor
      25                 :            : 
      26                 :        169 : Serializer::Serializer(bool store, bool calc_checksum)
      27                 :        169 :   : ISerializer(store)
      28                 :            : {
      29                 :        169 :   open_ = false;
      30                 :        169 :   calc_checksum_ = calc_checksum;
      31                 :        169 : }
      32                 :            : 
      33                 :        169 : Serializer::~Serializer()
      34                 :            : {
      35                 :        169 : }
      36                 :            : 
      37                 :            : /////////////
      38                 :            : // Operations
      39                 :            : 
      40                 :        171 : bool Serializer::open(std::string const &config, size_t &version_major, size_t &version_minor)
      41                 :            : {
      42         [ +  + ]:        171 :   if (isStoring())
      43                 :            :   {
      44                 :         12 :     version_major = VERSION_MAJOR;
      45                 :         12 :     version_minor = VERSION_MINOR;
      46                 :         12 :     return openForWrite(config);
      47                 :            :   }
      48                 :            :   else
      49                 :            :   {
      50                 :        159 :     return openForRead(config, version_major, version_minor);
      51                 :            :   }
      52                 :            : }
      53                 :            : 
      54                 :        170 : bool Serializer::close()
      55                 :            : {
      56         [ +  + ]:        170 :   if (open_)
      57                 :            :   {
      58         [ +  + ]:        168 :     if (isStoring())
      59                 :            :     {
      60                 :         12 :       return closeForWrite();
      61                 :            :     }
      62                 :            :     else
      63                 :            :     {
      64                 :        156 :       return closeForRead();
      65                 :            :     }
      66                 :            :   }
      67                 :            :   else
      68                 :            :   {
      69         [ +  - ]:          2 :     access::getLogger()->warn("Serializer: Attempt to close already closed stream.");
      70                 :          2 :     return false;
      71                 :            :   }
      72                 :            : }
      73                 :            : 
      74                 :            : //////////////
      75                 :            : // Aux Methods
      76                 :            : 
      77                 :        159 : bool Serializer::openForRead(std::string const &config, size_t &version_major, size_t &version_minor)
      78                 :            : {
      79         [ +  + ]:        159 :   if (doOpenForRead(config))
      80                 :            :   {
      81                 :        158 :     version_major = 0;
      82                 :        158 :     version_minor = 0;
      83                 :        158 :     size_t magic = 0;
      84         [ +  - ]:        158 :     initChecksum();
      85   [ +  -  +  +  :        158 :     if (ISerializer::serialize(magic) && ISerializer::serialize(version_major) && ISerializer::serialize(version_minor))
          +  -  +  -  +  
             -  +  -  +  
                      + ]
      86                 :            :     {
      87         [ +  - ]:        157 :       if (magic == MAGIC)
      88                 :            :       {
      89   [ +  +  +  - ]:        157 :         if (version_major == VERSION_MAJOR && version_minor == VERSION_MINOR)
      90                 :            :         {
      91                 :        156 :           open_ = true;
      92                 :        156 :           return true;
      93                 :            :         }
      94                 :            :         else
      95                 :            :         {
      96   [ +  -  +  - ]:          2 :           access::getLogger()->error(
      97                 :            :             "Serializer: Version mismatch: Expected {}, Found {}", VERSION_MAJOR, version_major);
      98         [ +  - ]:          1 :           throw std::runtime_error("Wrong map version!");
      99                 :            :         }
     100                 :            :       }
     101                 :            :       else
     102                 :            :       {
     103   [ #  #  #  # ]:          0 :         access::getLogger()->error("Serializer: Invalid stream {}", config);
     104                 :            :       }
     105                 :            :     }
     106                 :            :     else
     107                 :            :     {
     108   [ +  -  +  - ]:          2 :       access::getLogger()->error("Serializer: Invalid stream (too short) {}", config);
     109                 :            :     }
     110         [ +  - ]:          1 :     doCloseForRead();
     111                 :            :   }
     112                 :            :   else
     113                 :            :   {
     114         [ +  - ]:          2 :     access::getLogger()->error("Serializer: Cannot open stream for reading {}", config);
     115                 :            :   }
     116                 :          2 :   return false;
     117                 :            : }
     118                 :            : 
     119                 :         12 : bool Serializer::openForWrite(std::string const &config)
     120                 :            : {
     121         [ +  + ]:         12 :   if (doOpenForWrite(config))
     122                 :            :   {
     123                 :         11 :     initChecksum();
     124   [ +  -  +  -  :         11 :     if (ISerializer::serialize(MAGIC) && ISerializer::serialize(VERSION_MAJOR) && ISerializer::serialize(VERSION_MINOR))
             +  -  +  - ]
     125                 :            :     {
     126                 :         11 :       open_ = true;
     127                 :         11 :       return true;
     128                 :            :     }
     129                 :            :     else
     130                 :            :     {
     131         [ #  # ]:          0 :       access::getLogger()->error("Serializer: Cannot write header to steam {}", config);
     132                 :            :     }
     133                 :          0 :     doCloseForWrite();
     134                 :            :   }
     135                 :            :   else
     136                 :            :   {
     137         [ +  - ]:          2 :     access::getLogger()->error("Serializer: Cannot open stream for writing {}", config);
     138                 :            :   }
     139                 :          1 :   return false;
     140                 :            : }
     141                 :            : 
     142                 :        156 : bool Serializer::closeForRead()
     143                 :            : {
     144                 :        156 :   bool ret_val = false;
     145   [ +  -  +  +  :        156 :   if (!calc_checksum_ || checksumOK())
                   +  + ]
     146                 :            :   {
     147                 :        154 :     ret_val = true;
     148                 :            :   }
     149                 :            :   else
     150                 :            :   {
     151         [ +  - ]:          2 :     access::getLogger()->error("Serializer: Checksum mismatch!");
     152                 :            :   }
     153   [ +  +  +  + ]:        156 :   return doCloseForRead() && ret_val;
     154                 :            : }
     155                 :            : 
     156                 :         12 : bool Serializer::closeForWrite()
     157                 :            : {
     158                 :         12 :   bool ret_val = false;
     159   [ +  -  +  +  :         12 :   if (!calc_checksum_ || writeChecksum())
                   +  + ]
     160                 :            :   {
     161                 :         11 :     ret_val = true;
     162                 :            :   }
     163                 :            :   else
     164                 :            :   {
     165         [ +  - ]:          1 :     access::getLogger()->error("Serializer: Unable to write checksum.");
     166                 :            :   }
     167   [ +  +  +  - ]:         12 :   return doCloseForWrite() && ret_val;
     168                 :            : }
     169                 :            : 
     170                 :            : ////////////////////
     171                 :            : // Atomic Operations
     172                 :            : 
     173                 :     175867 : bool Serializer::write(const void *x, size_t bytes)
     174                 :            : {
     175         [ +  + ]:     175867 :   if (doWrite(x, bytes))
     176                 :            :   {
     177         [ +  - ]:     175866 :     if (calc_checksum_)
     178                 :            :     {
     179                 :     175866 :       updateChecksum(x, bytes);
     180                 :            :     }
     181                 :     175866 :     return true;
     182                 :            :   }
     183                 :            :   else
     184                 :            :   {
     185         [ +  - ]:          2 :     access::getLogger()->error("Serializer: Unable to write {} bytes", bytes);
     186                 :          1 :     return false;
     187                 :            :   }
     188                 :            : }
     189                 :            : 
     190                 :   10151200 : bool Serializer::read(void *x, size_t bytes)
     191                 :            : {
     192         [ +  + ]:   10151200 :   if (doRead(x, bytes))
     193                 :            :   {
     194         [ +  - ]:   10151200 :     if (calc_checksum_)
     195                 :            :     {
     196                 :   10151200 :       updateChecksum(x, bytes);
     197                 :            :     }
     198                 :   10151200 :     return true;
     199                 :            :   }
     200                 :            :   else
     201                 :            :   {
     202         [ +  - ]:          4 :     access::getLogger()->error("Serializer: Unable to read {} bytes", bytes);
     203                 :          2 :     return false;
     204                 :            :   }
     205                 :            : }
     206                 :            : 
     207                 :            : } // namespace serialize
     208                 :            : } // namespace map
     209                 :            : } // namespace ad