Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// `blaze::DynamicVector` is a general-purpose dynamically sized vector type.
       6             : /// This file implements interoperability of `blaze::DynamicVector` with our
       7             : /// data structures.
       8             : 
       9             : #pragma once
      10             : 
      11             : #include <blaze/math/DynamicVector.h>
      12             : #include <pup.h>
      13             : #include <type_traits>
      14             : #include <vector>
      15             : 
      16             : #include "Utilities/MakeWithValue.hpp"
      17             : 
      18             : /// \cond
      19             : namespace Options {
      20             : struct Option;
      21             : template <typename T>
      22             : struct create_from_yaml;
      23             : }  // namespace Options
      24             : /// \endcond
      25             : 
      26             : namespace PUP {
      27             : /// @{
      28             : /// Serialization of blaze::DynamicVector
      29             : template <typename T, bool TF, typename Tag>
      30             : void pup(er& p, blaze::DynamicVector<T, TF, Tag>& t) {
      31             :   size_t size = t.size();
      32             :   p | size;
      33             :   if (p.isUnpacking()) {
      34             :     t.resize(size);
      35             :   }
      36             :   if (std::is_fundamental_v<T>) {
      37             :     PUParray(p, t.data(), size);
      38             :   } else {
      39             :     for (T& element : t) {
      40             :       p | element;
      41             :     }
      42             :   }
      43             : }
      44             : template <typename T, bool TF, typename Tag>
      45             : void operator|(er& p, blaze::DynamicVector<T, TF, Tag>& t) {
      46             :   pup(p, t);
      47             : }
      48             : /// @}
      49             : }  // namespace PUP
      50             : 
      51           1 : namespace MakeWithValueImpls {
      52             : template <typename T, bool TF, typename Tag>
      53           0 : struct NumberOfPoints<blaze::DynamicVector<T, TF, Tag>> {
      54             :   static SPECTRE_ALWAYS_INLINE size_t
      55           0 :   apply(const blaze::DynamicVector<T, TF, Tag>& input) {
      56             :     return input.size();
      57             :   }
      58             : };
      59             : 
      60             : template <typename T, bool TF, typename Tag>
      61           0 : struct MakeWithSize<blaze::DynamicVector<T, TF, Tag>> {
      62           0 :   static SPECTRE_ALWAYS_INLINE blaze::DynamicVector<T, TF, Tag> apply(
      63             :       const size_t size, const T& value) {
      64             :     return blaze::DynamicVector<T, TF, Tag>(size, value);
      65             :   }
      66             : };
      67             : }  // namespace MakeWithValueImpls
      68             : 
      69             : namespace DynamicVector_detail {
      70             : template <typename T>
      71             : std::vector<T> parse_to_vector(const Options::Option& options);
      72             : }  // namespace DynamicVector_detail
      73             : 
      74             : template <typename T, bool TF, typename Tag>
      75           0 : struct Options::create_from_yaml<blaze::DynamicVector<T, TF, Tag>> {
      76             :   template <typename Metavariables>
      77           0 :   static blaze::DynamicVector<T, TF, Tag> create(
      78             :       const Options::Option& options) {
      79             :     const auto data = DynamicVector_detail::parse_to_vector<T>(options);
      80             :     blaze::DynamicVector<T, TF, Tag> result(data.size());
      81             :     std::copy(std::begin(data), std::end(data), result.begin());
      82             :     return result;
      83             :   }
      84             : };