Line data Source code
1 0 : // Distributed under the MIT License.
2 : // See LICENSE.txt for details.
3 :
4 : #pragma once
5 :
6 : #include <complex>
7 : #include <cstddef>
8 : #include <type_traits>
9 :
10 : #include "Utilities/ForceInline.hpp"
11 : #include "Utilities/Gsl.hpp"
12 : #include "Utilities/TypeTraits/IsComplexOfFundamental.hpp"
13 :
14 : /// \ingroup UtilitiesGroup
15 : /// \brief Callable struct which retrieves the `t.size()` for operand `t`. This
16 : /// will cause a compiler error if no such function exists.
17 1 : struct GetContainerSize {
18 : template <typename T>
19 0 : SPECTRE_ALWAYS_INLINE constexpr decltype(auto) operator()(const T& t) const {
20 : return t.size();
21 : }
22 : };
23 :
24 : /// \ingroup UtilitiesGroup
25 : /// \brief Callable struct for the subscript operator. Returns `t[i]`
26 1 : struct GetContainerElement {
27 : template <typename T>
28 0 : SPECTRE_ALWAYS_INLINE constexpr decltype(auto) operator()(
29 : T& t, const size_t i) const {
30 : return t[i];
31 : }
32 : };
33 :
34 : namespace ContainerHelpers_detail {
35 : // implementation struct for get_element and get_size
36 : template <bool IsFundamentalOrComplexOfFundamental>
37 : struct ContainerImpls;
38 :
39 : template <>
40 : struct ContainerImpls<true> {
41 : template <typename T, typename SubscriptFunction>
42 : static SPECTRE_ALWAYS_INLINE constexpr decltype(auto) get_element(
43 : T& t, const size_t /*i*/, const SubscriptFunction /*at*/) {
44 : return t;
45 : }
46 :
47 : template <typename T, typename SizeFunction>
48 : static SPECTRE_ALWAYS_INLINE constexpr size_t get_size(
49 : const T& /*t*/, const SizeFunction /*size*/) {
50 : return 1;
51 : }
52 : };
53 :
54 : template <>
55 : struct ContainerImpls<false> {
56 : template <typename T, typename SubscriptFunction>
57 : static SPECTRE_ALWAYS_INLINE constexpr decltype(auto) get_element(
58 : T& t, const size_t i, SubscriptFunction at) {
59 : return at(t, i);
60 : }
61 :
62 : template <typename T, typename SizeFunction>
63 : static SPECTRE_ALWAYS_INLINE constexpr decltype(auto) get_size(
64 : const T& t, SizeFunction size) {
65 : return size(t);
66 : }
67 : };
68 : } // namespace ContainerHelpers_detail
69 :
70 : /*!
71 : * \ingroup UtilitiesGroup
72 : * \brief Returns the `i`th element if `T` has a subscript operator, otherwise
73 : * if `T` is fundamental or a `std::complex` of a fundamental type, returns
74 : * `t`.
75 : *
76 : * \details This function also optionally takes the user-defined subscript
77 : * function `at`, which can be used to specify a custom indexing function. For
78 : * instance, for a type which is a `std::array` of a `std::array`s, the indexing
79 : * function could be the below callable struct:
80 : * \snippet Test_ContainerHelpers.cpp get_element_example_indexing_callable
81 : *
82 : * which would index the data structure in a manner in which the outer array
83 : * index varies fastest. The indexing function must take as arguments the
84 : * applicable container and a `size_t` index, in that order. This follows the
85 : * convention of `gsl::at`.
86 : * \note `std::complex` are regarded as non-indexable (despite a predictable
87 : * memory layout), so this function acts as the identity on `std::complex` of
88 : * fundamental types
89 : */
90 : template <typename T, typename SubscriptFunction = GetContainerElement>
91 1 : SPECTRE_ALWAYS_INLINE constexpr decltype(auto) get_element(
92 : T& t, const size_t i, SubscriptFunction at = GetContainerElement{}) {
93 : return ContainerHelpers_detail::ContainerImpls<(
94 : tt::is_complex_of_fundamental_v<std::remove_cv_t<T>> or
95 : std::is_fundamental_v<std::remove_cv_t<T>>)>::get_element(t, i, at);
96 : }
97 :
98 : /*!
99 : * \ingroup UtilitiesGroup
100 : * \brief Retrieve the size of `t` if `t.size()` is a valid expression,
101 : * otherwise if `T` is fundamental or a `std::complex` of a fundamental type,
102 : * returns 1.
103 : *
104 : * \details This function also optionally takes the user-defined `size`
105 : * function, which can be used to specify a custom size function. For
106 : * instance, for a type which is a `std::array` of a `std::array`, the size
107 : * function could be the below callable struct:
108 : * \snippet Test_ContainerHelpers.cpp get_size_example_size_callable
109 : *
110 : * The `size` function must take the single argument of the applicable
111 : * container, and should return a `size_t`. This follows the convention of
112 : * `std::size()` as of C++17.
113 : * \note `std::complex` are regarded as non-indexable (despite a predictable
114 : * memory layout), so this function will return 1 for a `std::complex` of a
115 : * fundamental type
116 : */
117 : template <typename T, typename SizeFunction = GetContainerSize>
118 1 : SPECTRE_ALWAYS_INLINE constexpr decltype(auto) get_size(
119 : const T& t, SizeFunction size = GetContainerSize{}) {
120 : return ContainerHelpers_detail::ContainerImpls<(
121 : tt::is_complex_of_fundamental_v<std::remove_cv_t<T>> or
122 : std::is_fundamental_v<std::remove_cv_t<T>>)>::get_size(t, size);
123 : }
124 :
125 : /// Fall-back that allows using `min(x)` where `x` can be a vector or a double
126 1 : SPECTRE_ALWAYS_INLINE constexpr double min(const double val) { return val; }
127 :
128 : /// Fall-back that allows using `max(x)` where `x` can be a vector or a double
129 1 : SPECTRE_ALWAYS_INLINE constexpr double max(const double val) { return val; }
|
