Line data Source code
1 1 : // Distributed under the MIT License.
2 : // See LICENSE.txt for details.
3 :
4 : /// \file
5 : /// Defines function dereference_wrapper
6 :
7 : #pragma once
8 :
9 : #include <complex>
10 : #include <functional>
11 : #include <utility>
12 :
13 : #include "Utilities/ForceInline.hpp"
14 : #include "Utilities/Math.hpp"
15 : #include "Utilities/Requires.hpp"
16 : #include "Utilities/TypeTraits/IsA.hpp"
17 :
18 : /// \ingroup UtilitiesGroup
19 : /// \brief Returns the reference object held by a reference wrapper, if a
20 : /// non-reference_wrapper type is passed in then the object is returned
21 : template <typename T>
22 1 : decltype(auto) dereference_wrapper(T&& t) {
23 : return std::forward<T>(t);
24 : }
25 :
26 : /// \cond
27 : template <typename T>
28 : T& dereference_wrapper(const std::reference_wrapper<T>& t) {
29 : return t.get();
30 : }
31 : template <typename T>
32 : T& dereference_wrapper(std::reference_wrapper<T>& t) {
33 : return t.get();
34 : }
35 : template <typename T>
36 : T&& dereference_wrapper(const std::reference_wrapper<T>&& t) {
37 : return t.get();
38 : }
39 : template <typename T>
40 : T&& dereference_wrapper(std::reference_wrapper<T>&& t) {
41 : return t.get();
42 : }
43 : /// \endcond
44 :
45 : /// \cond
46 : // Add overloads of math functions for reference_wrapper.
47 : // This is necessary because if a class, say DataVector, inherits from
48 : // blaze vector types and does not specify the math operators specifically for
49 : // DataVector then the implicit cast from reference_wrapper<DataVector> to
50 : // DataVector does not result in finding the math operators.
51 : //
52 : // We use forwarding references to resolve ambiguity errors with
53 : // DVecScalarMultExpr and DVecScalarDivExpr, with a std::reference_wrapper
54 : // The forwarding references match everything perfectly and so the functions
55 : // here will (almost) always win in overload selection.
56 : #define UNARY_REF_WRAP_OP(OP) \
57 : template <typename T> \
58 : SPECTRE_ALWAYS_INLINE decltype(auto) OP( \
59 : const std::reference_wrapper<T>& t) { \
60 : return OP(t.get()); \
61 : }
62 : #define BINARY_REF_WRAP_FUNCTION_OP(OP) \
63 : template < \
64 : typename T0, typename T1, \
65 : Requires<not tt::is_a_v<std::reference_wrapper, std::decay_t<T1>>> = \
66 : nullptr> \
67 : SPECTRE_ALWAYS_INLINE decltype(auto) OP( \
68 : const std::reference_wrapper<T0>& t0, T1&& t1) { \
69 : return OP(t0.get(), t1); \
70 : } \
71 : template < \
72 : typename T0, typename T1, \
73 : Requires<not tt::is_a_v<std::reference_wrapper, std::decay_t<T0>>> = \
74 : nullptr> \
75 : SPECTRE_ALWAYS_INLINE decltype(auto) OP( \
76 : T0&& t0, const std::reference_wrapper<T1>& t1) { \
77 : return OP(t0, t1.get()); \
78 : } \
79 : template <typename T0, typename T1> \
80 : SPECTRE_ALWAYS_INLINE decltype(auto) OP( \
81 : const std::reference_wrapper<T0>& t0, \
82 : const std::reference_wrapper<T1>& t1) { \
83 : return OP(t0.get(), t1.get()); \
84 : }
85 :
86 : #define BINARY_REF_WRAP_OP(OP) \
87 : template < \
88 : typename T0, typename T1, \
89 : Requires<not tt::is_a_v<std::reference_wrapper, std::decay_t<T1>>> = \
90 : nullptr> \
91 : SPECTRE_ALWAYS_INLINE decltype(auto) operator OP( \
92 : const std::reference_wrapper<T0>& t0, T1&& t1) { \
93 : return t0.get() OP t1; \
94 : } \
95 : template < \
96 : typename T0, typename T1, \
97 : Requires<not tt::is_a_v<std::reference_wrapper, std::decay_t<T0>>> = \
98 : nullptr> \
99 : SPECTRE_ALWAYS_INLINE decltype(auto) operator OP( \
100 : T0&& t0, const std::reference_wrapper<T1>& t1) { \
101 : return t0 OP t1.get(); \
102 : } \
103 : template <typename T0, typename T1> \
104 : SPECTRE_ALWAYS_INLINE decltype(auto) operator OP( \
105 : const std::reference_wrapper<T0>& t0, \
106 : const std::reference_wrapper<T1>& t1) { \
107 : return t0.get() OP t1.get(); \
108 : }
109 :
110 : UNARY_REF_WRAP_OP(abs)
111 : UNARY_REF_WRAP_OP(acos)
112 : UNARY_REF_WRAP_OP(acosh)
113 : UNARY_REF_WRAP_OP(asin)
114 : UNARY_REF_WRAP_OP(asinh)
115 : UNARY_REF_WRAP_OP(atan)
116 : BINARY_REF_WRAP_FUNCTION_OP(atan2)
117 : UNARY_REF_WRAP_OP(atanh)
118 : UNARY_REF_WRAP_OP(cbrt)
119 : UNARY_REF_WRAP_OP(conj)
120 : UNARY_REF_WRAP_OP(cos)
121 : UNARY_REF_WRAP_OP(cosh)
122 : UNARY_REF_WRAP_OP(erf)
123 : UNARY_REF_WRAP_OP(erfc)
124 : UNARY_REF_WRAP_OP(exp)
125 : UNARY_REF_WRAP_OP(exp2)
126 : UNARY_REF_WRAP_OP(exp10)
127 : UNARY_REF_WRAP_OP(fabs)
128 : BINARY_REF_WRAP_FUNCTION_OP(hypot)
129 : UNARY_REF_WRAP_OP(imag)
130 : UNARY_REF_WRAP_OP(invcbrt)
131 : UNARY_REF_WRAP_OP(invsqrt)
132 : UNARY_REF_WRAP_OP(log)
133 : UNARY_REF_WRAP_OP(log2)
134 : UNARY_REF_WRAP_OP(log10)
135 : UNARY_REF_WRAP_OP(max)
136 : UNARY_REF_WRAP_OP(min)
137 : BINARY_REF_WRAP_FUNCTION_OP(pow)
138 : UNARY_REF_WRAP_OP(real)
139 : UNARY_REF_WRAP_OP(sin)
140 : UNARY_REF_WRAP_OP(sinh)
141 : UNARY_REF_WRAP_OP(sqrt)
142 : UNARY_REF_WRAP_OP(step_function)
143 : UNARY_REF_WRAP_OP(tan)
144 : UNARY_REF_WRAP_OP(tanh)
145 :
146 : BINARY_REF_WRAP_OP(+)
147 : BINARY_REF_WRAP_OP(-)
148 : BINARY_REF_WRAP_OP(*)
149 : BINARY_REF_WRAP_OP(/)
150 : BINARY_REF_WRAP_OP(==)
151 :
152 : template <typename T>
153 : SPECTRE_ALWAYS_INLINE decltype(auto) operator-(
154 : const std::reference_wrapper<T>& t) {
155 : return -t.get();
156 : }
157 :
158 : #undef UNARY_REF_WRAP_OP
159 : #undef BINARY_REF_WRAP_OP
160 : #undef BINARY_REF_WRAP_FUNCTION_OP
161 : /// \endcond
|
