Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// PUP routines for new C+11 STL containers and other standard
       6             : /// library objects Charm does not provide implementations for
       7             : 
       8             : #pragma once
       9             : 
      10             : #include <cstddef>
      11             : #include <map>
      12             : #include <pup.h>
      13             : #include <pup_stl.h>
      14             : #include <utility>
      15             : 
      16             : namespace PUP {
      17             : 
      18             : /// \ingroup ParallelGroup
      19             : /// Serialization of std::atomic for Charm++
      20             : template <typename T>
      21             : void pup(PUP::er& p, std::atomic<T>& d) {  // NOLINT
      22             :   T local_d;
      23             :   if (p.isUnpacking()) {
      24             :     p | local_d;
      25             :     d.store(std::move(local_d));
      26             :   } else {
      27             :     local_d = d.load();
      28             :     p | local_d;
      29             :   }
      30             : }
      31             : 
      32             : /// \ingroup ParallelGroup
      33             : /// Serialization of std::atomic for Charm++
      34             : template <typename T>
      35             : void operator|(er& p, std::atomic<T>& d) {  // NOLINT
      36             :   pup(p, d);
      37             : }
      38             : }  // namespace PUP
      39             : 
      40             : /// \ingroup ParallelGroup
      41             : /// Temporary serialization function for a `std::map` with a comparator to
      42             : /// circumvent a charm bug.
      43             : template <typename K, typename T, typename C>
      44           1 : void pup_override(PUP::er& p, std::map<K, T, C>& m) {
      45             :   if (p.isUnpacking()) {
      46             :     size_t size;
      47             :     std::pair<K, T> pair;
      48             :     p | size;
      49             :     for (size_t i = 0; i < size; ++i) {
      50             :       p | pair;
      51             :       m.insert(pair);
      52             :     }
      53             :   } else {
      54             :     size_t size = m.size();
      55             :     p | size;
      56             :     for (auto& val : m) {
      57             :       p | val;
      58             :     }
      59             :   }
      60             : }