Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <array>
       7              : #include <complex>
       8              : #include <cstddef>
       9              : #include <type_traits>
      10              : #include <vector>
      11              : 
      12              : #include "Utilities/Gsl.hpp"
      13              : #include "Utilities/MakeWithValue.hpp"
      14              : #include "Utilities/TMPL.hpp"
      15              : 
      16              : /// Implementations of \link set_number_of_grid_points \endlink
      17              : ///
      18              : /// Specializations may be trivial, meaning the object is similar to a
      19              : /// `double` and doesn't actually represent grid data.  The only
      20              : /// requirement for trivial specializations is defining `is_trivial`
      21              : /// as `true`.
      22              : ///
      23              : /// Non-trivial specializations must define `is_trivial` to `false`,
      24              : /// and must define a static `apply` function with the signature shown
      25              : /// in the below example.  Non-trivial specializations must also be
      26              : /// accompanied by a specialization of the
      27              : /// MakeWithValueImpls::NumberOfPoints struct.  The `apply` function
      28              : /// will only be called if the current size is incorrect, so
      29              : /// implementations should not check the current size.
      30              : ///
      31              : /// \snippet Test_SetNumberOfGridPoints.cpp SetNumberOfGridPointsImpl
      32            1 : namespace SetNumberOfGridPointsImpls {
      33              : /// Default implementation is not defined.
      34              : template <typename T, typename = std::nullptr_t>
      35            1 : struct SetNumberOfGridPointsImpl;
      36              : }  // namespace SetNumberOfGridPointsImpls
      37              : 
      38              : /// \ingroup DataStructuresGroup
      39              : /// Change the number of grid points in an object.
      40              : ///
      41              : /// Change the number of points stored in \p result to a given value
      42              : /// or to match another object.  If \p pattern is a `size_t` it will
      43              : /// be used as the number of points, otherwise it will be interpreted
      44              : /// as data on a collection of grid points.
      45              : ///
      46              : /// \see SetNumberOfGridPointsImpls, make_with_value
      47              : template <typename T, typename U>
      48            1 : void set_number_of_grid_points(const gsl::not_null<T*> result,
      49              :                                const U& pattern) {
      50              :   (void)result;
      51              :   (void)pattern;
      52              :   if constexpr (not SetNumberOfGridPointsImpls::SetNumberOfGridPointsImpl<
      53              :                     T>::is_trivial) {
      54              :     const size_t size = MakeWithValueImpls::number_of_points(pattern);
      55              :     if (UNLIKELY(MakeWithValueImpls::number_of_points(*result) != size)) {
      56              :       SetNumberOfGridPointsImpls::SetNumberOfGridPointsImpl<T>::apply(result,
      57              :                                                                       size);
      58              :     }
      59              :   }
      60              : }
      61              : 
      62              : template <>
      63            0 : struct SetNumberOfGridPointsImpls::SetNumberOfGridPointsImpl<double> {
      64            0 :   static constexpr bool is_trivial = true;
      65              : };
      66              : 
      67              : template <>
      68              : struct SetNumberOfGridPointsImpls::SetNumberOfGridPointsImpl<
      69              :     std::complex<double>> {
      70              :   static constexpr bool is_trivial = true;
      71              : };
      72              : 
      73              : template <typename T, size_t N>
      74              : struct SetNumberOfGridPointsImpls::SetNumberOfGridPointsImpl<std::array<T, N>> {
      75              :   static constexpr bool is_trivial =
      76              :       N == 0 or SetNumberOfGridPointsImpl<T>::is_trivial;
      77              :   static void apply(const gsl::not_null<std::array<T, N>*> result,
      78              :                     const size_t size) {
      79              :     for (auto& entry : *result) {
      80              :       set_number_of_grid_points(make_not_null(&entry), size);
      81              :     }
      82              :   }
      83              : };
      84              : 
      85              : template <typename T>
      86              : struct SetNumberOfGridPointsImpls::SetNumberOfGridPointsImpl<std::vector<T>> {
      87              :   static constexpr bool is_trivial = SetNumberOfGridPointsImpl<T>::is_trivial;
      88              :   static void apply(const gsl::not_null<std::vector<T>*> result,
      89              :                     const size_t size) {
      90              :     for (auto& entry : *result) {
      91              :       set_number_of_grid_points(make_not_null(&entry), size);
      92              :     }
      93              :   }
      94              : };
      95              :