77#include < memory>
88#include < type_traits>
99#include < utility>
10-
1110/* *
1211 * \defgroup eigen_expressions Eigen expressions
1312 */
@@ -250,13 +249,17 @@ namespace math {
250249 */
251250template <typename T, typename ... Ptrs,
252251 std::enable_if_t <sizeof ...(Ptrs) >= 1 >* = nullptr >
253- Holder<T, Ptrs...> holder (T&& arg, Ptrs*... pointers) {
252+ inline Holder<T, Ptrs...> holder (T&& arg, Ptrs*... pointers) {
254253 return Holder<T, Ptrs...>(std::forward<T>(arg), pointers...);
255254}
256255// trivial case with no pointers constructs no holder object
257256template <typename T>
258- T holder (T&& arg) {
259- return std::forward<T>(arg);
257+ inline decltype (auto ) holder(T&& arg) {
258+ if constexpr (std::is_rvalue_reference<T&&>::value) {
259+ return std::decay_t <T>(std::forward<T>(arg));
260+ } else {
261+ return std::forward<T>(arg);
262+ }
260263}
261264
262265namespace internal {
@@ -271,14 +274,14 @@ namespace internal {
271274 * @return tuple of pointers allocated on heap (empty).
272275 */
273276template <typename T>
274- auto holder_handle_element (T& a, T*& res) {
277+ inline auto holder_handle_element (T& a, T*& res) {
275278 res = &a;
276279 return std::make_tuple ();
277280}
278281template <typename T,
279282 std::enable_if_t <!(Eigen::internal::traits<std::decay_t <T>>::Flags
280283 & Eigen::NestByRefBit)>* = nullptr >
281- auto holder_handle_element (T&& a, std::remove_reference_t <T>*& res) {
284+ inline auto holder_handle_element (T&& a, std::remove_reference_t <T>*& res) {
282285 res = &a;
283286 return std::make_tuple ();
284287}
@@ -297,13 +300,13 @@ template <typename T, require_t<std::is_rvalue_reference<T&&>>* = nullptr,
297300 std::enable_if_t <
298301 static_cast <bool >(Eigen::internal::traits<std::decay_t <T>>::Flags&
299302 Eigen::NestByRefBit)>* = nullptr >
300- auto holder_handle_element (T&& a, T*& res) {
303+ inline auto holder_handle_element (T&& a, T*& res) {
301304 res = new T (std::move (a));
302305 return std::make_tuple (res);
303306}
304307template <typename T, require_t <std::is_rvalue_reference<T&&>>* = nullptr ,
305308 require_not_eigen_t <T>* = nullptr >
306- auto holder_handle_element (T&& a, T*& res) {
309+ inline auto holder_handle_element (T&& a, T*& res) {
307310 res = new T (std::move (a));
308311 return std::make_tuple (res);
309312}
@@ -320,7 +323,7 @@ auto holder_handle_element(T&& a, T*& res) {
320323 * @return `holder` referencing given expression
321324 */
322325template <typename T, std::size_t ... Is, typename ... Args>
323- auto make_holder_impl_construct_object (T&& expr, std::index_sequence<Is...>,
326+ inline auto make_holder_impl_construct_object (T&& expr, std::index_sequence<Is...>,
324327 const std::tuple<Args*...>& ptrs) {
325328 return holder (std::forward<T>(expr), std::get<Is>(ptrs)...);
326329}
@@ -335,13 +338,13 @@ auto make_holder_impl_construct_object(T&& expr, std::index_sequence<Is...>,
335338 * @return `holder` referencing expression constructed by given functor
336339 */
337340template <typename F, std::size_t ... Is, typename ... Args>
338- auto make_holder_impl (const F & func, std::index_sequence<Is...>,
341+ inline auto make_holder_impl (F& & func, std::index_sequence<Is...>,
339342 Args&&... args) {
340343 std::tuple<std::remove_reference_t <Args>*...> res;
341344 auto ptrs = std::tuple_cat (
342345 holder_handle_element (std::forward<Args>(args), std::get<Is>(res))...);
343346 return make_holder_impl_construct_object (
344- func (*std::get<Is>(res)...),
347+ std::forward<F>( func) (*std::get<Is>(res)...),
345348 std::make_index_sequence<std::tuple_size<decltype (ptrs)>::value>(), ptrs);
346349}
347350
@@ -362,8 +365,8 @@ auto make_holder_impl(const F& func, std::index_sequence<Is...>,
362365template <
363366 typename F, typename ... Args,
364367 require_not_plain_type_t <std::invoke_result_t <F, Args&&...>>* = nullptr >
365- auto make_holder (const F & func, Args&&... args) {
366- return internal::make_holder_impl (func,
368+ inline auto make_holder (F& & func, Args&&... args) {
369+ return internal::make_holder_impl (std::forward<F>( func) ,
367370 std::make_index_sequence<sizeof ...(Args)>(),
368371 std::forward<Args>(args)...);
369372}
@@ -380,8 +383,8 @@ auto make_holder(const F& func, Args&&... args) {
380383 */
381384template <typename F, typename ... Args,
382385 require_plain_type_t <std::invoke_result_t <F, Args&&...>>* = nullptr >
383- auto make_holder (const F & func, Args&&... args) {
384- return func (std::forward<Args>(args)...);
386+ inline auto make_holder (F& & func, Args&&... args) {
387+ return std::forward<F>( func) (std::forward<Args>(args)...);
385388}
386389
387390} // namespace math
0 commit comments