Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <cassert>
       7             : #include <optional>
       8             : #include <pup_stl.h>
       9             : #include <utility>
      10             : #include <variant>
      11             : 
      12             : #include "Utilities/Gsl.hpp"
      13             : #include "Utilities/TMPL.hpp"
      14             : 
      15             : namespace PUP {
      16             : /// \ingroup ParallelGroup
      17             : /// Serialization of std::optional for Charm++
      18             : template <typename T>
      19             : void pup(er& p, std::optional<T>& t) {  // NOLINT
      20             :   bool valid = false;
      21             :   if (p.isUnpacking()) {
      22             :     p | valid;
      23             :     if (valid) {
      24             :       // default construct in a manner that doesn't require a copy.
      25             :       // This is necessary when holding objects like pair<const Key, unique_ptr>
      26             :       // in unordered map-type structures. The reason this case is tricky is
      27             :       // because the const Key is non-movable while the unique_ptr is
      28             :       // non-copyable. Our only option is in-place construction.
      29             :       t.emplace();
      30             :       p | *t;
      31             :     } else {
      32             :       t.reset();
      33             :     }
      34             :   } else {
      35             :     valid = t.has_value();
      36             :     p | valid;
      37             :     if (valid) {
      38             :       p | *t;
      39             :     }
      40             :   }
      41             : }
      42             : 
      43             : /// \ingroup ParallelGroup
      44             : /// Serialization of std::optional for Charm++
      45             : template <typename T>
      46             : void operator|(er& p, std::optional<T>& t) {  // NOLINT
      47             :   pup(p, t);
      48             : }
      49             : 
      50             : /// \ingroup ParallelGroup
      51             : /// Serialization of std::variant for Charm++
      52             : template <typename... Ts>
      53             : void pup(er& p, std::variant<Ts...>& t) {  // NOLINT
      54             :   // clang tidy: complains about pointer decay, I don't understand the error
      55             :   // since nothing here is doing anything with pointers.
      56             :   assert(not t.valueless_by_exception());  // NOLINT
      57             : 
      58             :   size_t current_index = 0;
      59             :   size_t send_index = t.index();
      60             :   p | send_index;
      61             : 
      62             :   const auto pup_helper = [&current_index, &p, send_index, &t](auto type_v) {
      63             :     using type = tmpl::type_from<decltype(type_v)>;
      64             :     if (UNLIKELY(current_index == send_index)) {
      65             :       if (p.isUnpacking()) {
      66             :         type temp{};
      67             :         p | temp;
      68             :         t = std::move(temp);
      69             :       } else {
      70             :         p | std::get<type>(t);
      71             :       }
      72             :     }
      73             :     ++current_index;
      74             :   };
      75             :   EXPAND_PACK_LEFT_TO_RIGHT(pup_helper(tmpl::type_<Ts>{}));
      76             : }
      77             : 
      78             : /// \ingroup ParallelGroup
      79             : /// Serialization of std::variant for Charm++
      80             : template <typename... Ts>
      81             : void operator|(er& p, std::variant<Ts...>& t) {  // NOLINT
      82             :   pup(p, t);
      83             : }
      84             : }  // namespace PUP