Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines helper functions for working with boost.
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <boost/container/small_vector.hpp>
      10             : #include <boost/container/static_vector.hpp>
      11             : #include <boost/math/quaternion.hpp>
      12             : #include <boost/rational.hpp>
      13             : #include <pup.h>
      14             : 
      15             : namespace PUP {
      16             : /// @{
      17             : /// \ingroup ParallelGroup
      18             : /// Serialization of boost::rational for Charm++
      19             : template <class T>
      20             : void pup(PUP::er& p, boost::rational<T>& var) {  // NOLINT
      21             :   if (p.isUnpacking()) {
      22             :     typename boost::rational<T>::int_type n, d;
      23             :     p | n;
      24             :     p | d;
      25             :     var.assign(n, d);
      26             :   } else {
      27             :     typename boost::rational<T>::int_type n = var.numerator();
      28             :     typename boost::rational<T>::int_type d = var.denominator();
      29             :     p | n;
      30             :     p | d;
      31             :   }
      32             : }
      33             : 
      34             : template <typename T>
      35             : inline void operator|(PUP::er& p, boost::rational<T>& var) {  // NOLINT
      36             :   pup(p, var);
      37             : }
      38             : /// @}
      39             : 
      40             : template <class T, size_t N>
      41             : void pup(PUP::er& p, boost::container::static_vector<T, N>& v) {
      42             :   auto size = v.size();
      43             :   p | size;
      44             :   v.resize(size);
      45             :   if (PUP::as_bytes<T>::value) {
      46             :     PUParray(p, v.data(), size);
      47             :   } else {
      48             :     for (auto& x : v) {
      49             :       p | x;
      50             :     }
      51             :   }
      52             : }
      53             : 
      54             : template <class T, size_t N>
      55             : void operator|(PUP::er& p, boost::container::static_vector<T, N>& v) {
      56             :   pup(p, v);
      57             : }
      58             : 
      59             : template <class T, size_t N>
      60             : void pup(PUP::er& p, boost::container::small_vector<T, N>& v) {
      61             :   auto size = v.size();
      62             :   p | size;
      63             :   v.resize(size);
      64             :   if (PUP::as_bytes<T>::value) {
      65             :     PUParray(p, v.data(), size);
      66             :   } else {
      67             :     for (auto& x : v) {
      68             :       p | x;
      69             :     }
      70             :   }
      71             : }
      72             : 
      73             : template <class T, size_t N>
      74             : void operator|(PUP::er& p, boost::container::small_vector<T, N>& v) {
      75             :   pup(p, v);
      76             : }
      77             : 
      78             : template <typename T>
      79             : void pup(PUP::er& p, boost::math::quaternion<T>& quaternion) {
      80             :   T component_1 = quaternion.R_component_1();
      81             :   T component_2 = quaternion.R_component_2();
      82             :   T component_3 = quaternion.R_component_3();
      83             :   T component_4 = quaternion.R_component_4();
      84             :   p | component_1;
      85             :   p | component_2;
      86             :   p | component_3;
      87             :   p | component_4;
      88             :   if (p.isUnpacking()) {
      89             :     quaternion = boost::math::quaternion<T>(component_1, component_2,
      90             :                                             component_3, component_4);
      91             :   }
      92             : }
      93             : 
      94             : template <typename T>
      95             : void operator|(PUP::er& p, boost::math::quaternion<T>& quaternion) {
      96             :   pup(p, quaternion);
      97             : }
      98             : }  // namespace PUP