Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <functional>
       7             : #include <limits>
       8             : #include <pup.h>
       9             : #include <type_traits>
      10             : #include <utility>
      11             : 
      12             : /// \ingroup TimeGroup
      13             : /// Implementation of \ref evolution_less, \ref evolution_greater,
      14             : /// \ref evolution_less_equal, and \ref evolution_greater_equal.
      15             : ///
      16             : /// This should only be used through the named aliases, but provides
      17             : /// the documentation of the members.
      18             : /// @{
      19             : template <typename T, template <typename> typename Comparator>
      20           1 : struct evolution_comparator {
      21           0 :   bool time_runs_forward = true;
      22           0 :   constexpr bool operator()(const T& x, const T& y) const {
      23             :     return time_runs_forward ? Comparator<T>{}(x, y) : Comparator<T>{}(y, x);
      24             :   }
      25             : 
      26             :   /// Provides an infinite (in the sense of
      27             :   /// std::numeric_limits::infinity()) value that compares greater
      28             :   /// than any other value in the evolution ordering.
      29             :   template <typename U = T>
      30           1 :   constexpr U infinity() const {
      31             :     static_assert(std::numeric_limits<U>::has_infinity);
      32             :     return time_runs_forward ? std::numeric_limits<U>::infinity()
      33             :                              : -std::numeric_limits<U>::infinity();
      34             :   }
      35             : 
      36             :   // NOLINTNEXTLINE(google-runtime-references)
      37           0 :   void pup(PUP::er& p) { p | time_runs_forward; }
      38             : };
      39             : 
      40             : template <template <typename> typename Comparator>
      41           0 : struct evolution_comparator<void, Comparator> {
      42           0 :   bool time_runs_forward = true;
      43             : 
      44             :   template <typename T, typename U>
      45           0 :   constexpr decltype(auto) operator()(T&& t, U&& u) const {
      46             :     static_assert(std::is_same_v<decltype(Comparator<void>{}(
      47             :                                      std::forward<T>(t), std::forward<U>(u))),
      48             :                                  decltype(Comparator<void>{}(
      49             :                                      std::forward<U>(u), std::forward<T>(t)))>,
      50             :                   "The return types of operators used in evolution comparators "
      51             :                   "must be symmetric in their arguments.");
      52             :     return time_runs_forward
      53             :                ? Comparator<void>{}(std::forward<T>(t), std::forward<U>(u))
      54             :                : Comparator<void>{}(std::forward<U>(u), std::forward<T>(t));
      55             :   }
      56             : 
      57             :   /// \copydoc evolution_comparator::infinity
      58             :   template <typename U>
      59           1 :   constexpr U infinity() const {
      60             :     static_assert(std::numeric_limits<U>::has_infinity);
      61             :     return time_runs_forward ? std::numeric_limits<U>::infinity()
      62             :                              : -std::numeric_limits<U>::infinity();
      63             :   }
      64             : 
      65             :   // NOLINTNEXTLINE(google-runtime-references)
      66           0 :   void pup(PUP::er& p) { p | time_runs_forward; }
      67             : };
      68             : /// @}
      69             : 
      70             : /// \ingroup TimeGroup
      71             : /// Ordering functors that reverse their order when time runs
      72             : /// backwards.  See evolution_comparator and
      73             : /// evolution_comparator<void,Comparator> for the provided interface.
      74             : ///
      75             : /// \see std::less
      76             : template <typename T = void>
      77           1 : using evolution_less = evolution_comparator<T, std::less>;
      78             : 
      79             : /// \ingroup TimeGroup
      80             : /// \copydoc evolution_less
      81             : template <typename T = void>
      82           1 : using evolution_greater = evolution_comparator<T, std::greater>;
      83             : 
      84             : /// \ingroup TimeGroup
      85             : /// \copydoc evolution_less
      86             : template <typename T = void>
      87           1 : using evolution_less_equal = evolution_comparator<T, std::less_equal>;
      88             : 
      89             : /// \ingroup TimeGroup
      90             : /// \copydoc evolution_less
      91             : template <typename T = void>
      92           1 : using evolution_greater_equal = evolution_comparator<T, std::greater_equal>;