Branch data     Line data    Source code

       1                 :             : #include "Communicate/LogEntry.h"
       2                 :             : 
       3                 :             : namespace ippl {
       4                 :             : 
       5                 :          12 :     void serializeString(std::vector<char>& buffer, const std::string& str) {
       6                 :          12 :         size_t length = str.size();
       7         [ +  - ]:          12 :         serializeBasicType(buffer, length);  // First, serialize the length of the string
       8         [ +  - ]:          12 :         buffer.insert(buffer.end(), str.begin(), str.end());  // Then, serialize the string itself
       9                 :          12 :     }
      10                 :             : 
      11                 :           6 :     std::string deserializeString(const std::vector<char>& buffer, size_t& offset) {
      12                 :             :         size_t length =
      13                 :           6 :             deserializeBasicType<size_t>(buffer, offset);  // Get the length of the string
      14                 :           0 :         std::string str(buffer.begin() + offset,
      15         [ +  - ]:           6 :                         buffer.begin() + offset + length);  // Extract the string
      16                 :           6 :         offset += length;
      17                 :           6 :         return str;
      18                 :             :     }
      19                 :             : 
      20                 :           2 :     std::vector<char> LogEntry::serialize() const {
      21                 :           2 :         std::vector<char> buffer;
      22                 :             : 
      23         [ +  - ]:           2 :         serializeString(buffer, methodName);
      24         [ +  - ]:           2 :         serializeBasicType(buffer, usedSize);
      25         [ +  - ]:           2 :         serializeBasicType(buffer, freeSize);
      26         [ +  - ]:           2 :         serializeString(buffer, memorySpace);
      27         [ +  - ]:           2 :         serializeBasicType(buffer, rank);
      28                 :             : 
      29                 :             :         // Serialize the timestamp (as duration since epoch)
      30                 :           2 :         auto duration = timestamp.time_since_epoch().count();
      31         [ +  - ]:           2 :         serializeBasicType(buffer, duration);
      32                 :             : 
      33                 :           2 :         size_t mapSize = parameters.size();
      34         [ +  - ]:           2 :         serializeBasicType(buffer, mapSize);
      35         [ +  + ]:           6 :         for (const auto& pair : parameters) {
      36         [ +  - ]:           4 :             serializeString(buffer, pair.first);
      37         [ +  - ]:           4 :             serializeString(buffer, pair.second);
      38                 :             :         }
      39                 :             : 
      40                 :           2 :         return buffer;
      41                 :           0 :     }
      42                 :             : 
      43                 :           1 :     LogEntry LogEntry::deserialize(const std::vector<char>& buffer, size_t offset) {
      44         [ +  - ]:           1 :         LogEntry entry;
      45                 :           1 :         size_t current_pos = offset;
      46                 :             : 
      47         [ +  - ]:           1 :         entry.methodName  = deserializeString(buffer, current_pos);
      48                 :           1 :         entry.usedSize    = deserializeBasicType<size_t>(buffer, current_pos);
      49                 :           1 :         entry.freeSize    = deserializeBasicType<size_t>(buffer, current_pos);
      50         [ +  - ]:           1 :         entry.memorySpace = deserializeString(buffer, current_pos);
      51                 :           1 :         entry.rank        = deserializeBasicType<int>(buffer, current_pos);
      52                 :             : 
      53                 :           1 :         auto duration   = deserializeBasicType<long long>(buffer, current_pos);
      54                 :           1 :         entry.timestamp = std::chrono::time_point<std::chrono::high_resolution_clock>(
      55                 :           1 :             std::chrono::high_resolution_clock::duration(duration));
      56                 :             : 
      57                 :           1 :         size_t mapSize = deserializeBasicType<size_t>(buffer, current_pos);
      58         [ +  + ]:           3 :         for (size_t i = 0; i < mapSize; ++i) {
      59         [ +  - ]:           2 :             std::string key       = deserializeString(buffer, current_pos);
      60         [ +  - ]:           2 :             std::string value     = deserializeString(buffer, current_pos);
      61   [ +  -  +  - ]:           2 :             entry.parameters[key] = value;
      62                 :           2 :         }
      63                 :             : 
      64                 :           1 :         return entry;
      65                 :           0 :     }
      66                 :             : 
      67                 :             : }  // namespace ippl