Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines the serialize and deserialize functions.
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <pup.h>
      10             : #include <type_traits>
      11             : #include <vector>
      12             : 
      13             : #include "Utilities/Gsl.hpp"
      14             : 
      15             : /*!
      16             :  * \ingroup ParallelGroup
      17             :  * \brief Serialize an object using PUP.
      18             :  *
      19             :  * The type to serialize as must be explicitly specified.  We require
      20             :  * this because a mismatch between the serialize and deserialize calls
      21             :  * causes undefined behavior and we do not want this to depend on
      22             :  * inferred types for safety.
      23             :  *
      24             :  * \tparam T type to serialize
      25             :  */
      26             : template <typename T>
      27           1 : std::vector<char> serialize(const T& obj) {
      28             :   const T& typed_obj = obj;
      29             :   // pup routine is non-const, but shouldn't modify anything in serialization
      30             :   // mode.
      31             :   // clang-tidy: do not use const_cast
      32             :   auto& mut_obj = const_cast<T&>(typed_obj);  // NOLINT
      33             : 
      34             :   PUP::sizer sizer;
      35             :   sizer | mut_obj;
      36             :   std::vector<char> data(sizer.size());
      37             :   PUP::toMem writer(data.data());
      38             :   writer | mut_obj;
      39             : 
      40             :   return data;
      41             : }
      42             : 
      43             : /*!
      44             :  * \ingroup ParallelGroup
      45             :  * \brief Deserialize an object using PUP.
      46             :  *
      47             :  * \tparam T the type to deserialize to
      48             :  */
      49             : template <typename T>
      50           1 : T deserialize(const void* const data) {  // NOLINT
      51             :   // clang-tidy: no const in forward decl (this is a definition)
      52             :   PUP::fromMem reader(data);
      53             :   T result{};
      54             :   reader | result;
      55             :   return result;
      56             : }
      57             : 
      58             : /*!
      59             :  * \ingroup ParallelGroup
      60             :  * \brief Deserialize an object using PUP.
      61             :  *
      62             :  * \tparam T the type to deserialize to.
      63             :  */
      64             : template <typename T>
      65           1 : void deserialize(const gsl::not_null<T*> result,
      66             :                  const void* const data) {  // NOLINT
      67             :   // clang-tidy: no const in forward decl (this is a definition)
      68             :   PUP::fromMem reader(data);
      69             :   reader | *result;
      70             : }
      71             : 
      72             : /*!
      73             :  * \ingroup ParallelGroup
      74             :  * \brief Returns the size of an object in bytes
      75             :  */
      76             : template <typename T>
      77           1 : size_t size_of_object_in_bytes(const T& obj) {
      78             :   PUP::sizer sizer;
      79             :   sizer | const_cast<T&>(obj);  // NOLINT
      80             :   return sizer.size();
      81             : }
      82             : 
      83             : /*!
      84             :  * \ingroup ParallelGroup
      85             :  * \brief Serializes and deserializes an object `t` of type `T`
      86             :  *
      87             :  * Performs a PUP round-trip on `t`, returning the deserialized copy.
      88             :  * Useful for testing that a class is correctly serializable, and for
      89             :  * copying objects that store state in a way only accessible via PUP.
      90             :  *
      91             :  * \requires `T` to be default constructible.
      92             :  */
      93             : template <typename T>
      94           1 : T serialize_and_deserialize(const T& t) {
      95             :   static_assert(
      96             :       std::is_default_constructible_v<T>,
      97             :       "Cannot use serialize_and_deserialize if a class is not default "
      98             :       "constructible.");
      99             :   return deserialize<T>(serialize<T>(t).data());
     100             : }
     101             : 
     102             : /*!
     103             :  * \ingroup ParallelGroup
     104             :  * \brief Serializes and deserializes an object `t` of type `T` into `result`
     105             :  *
     106             :  * Performs a PUP round-trip on `t`, writing the deserialized value into
     107             :  * the pre-existing object pointed to by `result`.
     108             :  *
     109             :  * Unlike the value-returning overload, `T` does not need to be default
     110             :  * constructible, since the result is written into the pre-existing `*result`.
     111             :  */
     112             : template <typename T>
     113           1 : void serialize_and_deserialize(const gsl::not_null<T*> result, const T& t) {
     114             :   deserialize<T>(result, serialize<T>(t).data());
     115             : }