Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <type_traits>
       7              : 
       8              : #include "DataStructures/DataBox/DataBox.hpp"
       9              : #include "DataStructures/TempBuffer.hpp"
      10              : #include "Utilities/Gsl.hpp"
      11              : #include "Utilities/Requires.hpp"
      12              : #include "Utilities/TMPL.hpp"
      13              : #include "Utilities/TypeTraits/IsA.hpp"
      14              : 
      15              : /// @{
      16              : /*!
      17              :  * \ingroup DataStructuresGroup
      18              :  * \brief Retrieves a desired tag from data structures containing tags.
      19              :  *
      20              :  * \details Given multiple containers retrieve a desired tag from the first
      21              :  * container in which it is found. The containers are searched in the order
      22              :  * in which they are supplied (i.e. `first_vars` is checked before `vars`).
      23              :  * An error will be emitted if the tag cannot be found in any container.
      24              :  */
      25              : template <typename Tag, typename... TagsOrTagsList, typename... Ts,
      26              :           template <class...> class U,
      27              :           Requires<(not tt::is_a_v<gsl::not_null, U<TagsOrTagsList...>>)and not(
      28              :               ... and tt::is_a_v<gsl::not_null, std::decay_t<Ts>>)> = nullptr>
      29            1 : const typename Tag::type& get(const U<TagsOrTagsList...>& first_vars,
      30              :                               const Ts&... vars) {
      31              :   if constexpr (tt::is_a_v<db::DataBox, U<TagsOrTagsList...>>) {
      32              :     if constexpr (not db::tag_is_retrievable_v<Tag, U<TagsOrTagsList...>> and
      33              :                   sizeof...(Ts) != 0) {
      34              :       return get<Tag>(vars...);
      35              :     } else {
      36              :       return get<Tag>(first_vars);
      37              :     }
      38              :   } else {
      39              :     if constexpr (not tmpl::list_contains_v<
      40              :                       tmpl::flatten<tmpl::list<TagsOrTagsList...>>, Tag> and
      41              :                   sizeof...(Ts) != 0) {
      42              :       return get<Tag>(vars...);
      43              :     } else {
      44              :       return get<Tag>(first_vars);
      45              :     }
      46              :   }
      47              : }
      48              : 
      49              : template <typename Tag, typename... TagsOrTagsList, typename... Ts,
      50              :           template <class...> class U>
      51            1 : gsl::not_null<typename Tag::type*> get(
      52              :     const gsl::not_null<U<TagsOrTagsList...>*> first_vars,
      53              :     const gsl::not_null<Ts>... vars) {
      54              :   if constexpr (tt::is_a_v<db::DataBox, U<TagsOrTagsList...>>) {
      55              :     if constexpr (not db::tag_is_retrievable_v<Tag, U<TagsOrTagsList...>> and
      56              :                   sizeof...(Ts) != 0) {
      57              :       if constexpr (sizeof...(Ts) == 1) {
      58              :         return make_not_null(&get<Tag>(*vars...));
      59              :       } else {
      60              :         return get<Tag>(vars...);
      61              :       }
      62              :     } else {
      63              :       return make_not_null(&get<Tag>(*first_vars));
      64              :     }
      65              :   } else {
      66              :     if constexpr (not tmpl::list_contains_v<
      67              :                       tmpl::flatten<tmpl::list<TagsOrTagsList...>>, Tag> and
      68              :                   sizeof...(Ts) != 0) {
      69              :       (void)first_vars;
      70              :       if constexpr (sizeof...(Ts) == 1) {
      71              :         return make_not_null(&get<Tag>(*vars...));
      72              :       } else {
      73              :         return get<Tag>(vars...);
      74              :       }
      75              :     } else {
      76              :       return make_not_null(&get<Tag>(*first_vars));
      77              :     }
      78              :   }
      79              : }
      80              : /// @}
      81              : 
      82              : namespace detail {
      83              : template <typename Callable, typename T, typename... Args,
      84              :           typename... ReturnTags, typename... ArgumentTags>
      85              : auto apply_impl([[maybe_unused]] const gsl::not_null<T*> return_args,
      86              :                 tmpl::list<ReturnTags...> /*meta*/,
      87              :                 tmpl::list<ArgumentTags...> /*meta*/, Callable&& fn,
      88              :                 const Args&... args) {
      89              :   return fn.apply(get<ReturnTags>(return_args)...,
      90              :                   get<ArgumentTags>(args...)...);
      91              : }
      92              : 
      93              : template <typename Callable, typename T, typename... Args,
      94              :           typename... ReturnTags, typename... ArgumentTags>
      95              : auto invoke_impl([[maybe_unused]] const gsl::not_null<T*> return_args,
      96              :                  tmpl::list<ReturnTags...> /*meta*/,
      97              :                  tmpl::list<ArgumentTags...> /*meta*/, Callable&& fn,
      98              :                  const Args&... args) {
      99              :   return fn(get<ReturnTags>(return_args)..., get<ArgumentTags>(args...)...);
     100              : }
     101              : }  // namespace detail
     102              : 
     103              : /*!
     104              :  * \brief Call
     105              :  * `fn.apply(get<Callable::return_tags>(return_args)...,
     106              :  * get<Callable::argument_tags>(args...))`
     107              :  */
     108              : template <typename Callable, typename T, typename... Args>
     109            1 : auto apply(const gsl::not_null<T*> return_args, Callable&& fn,
     110              :            const Args&... args) {
     111              :   return detail::apply_impl(return_args, typename Callable::return_tags{},
     112              :                             typename Callable::argument_tags{},
     113              :                             std::forward<Callable>(fn), args...);
     114              : }
     115              : 
     116              : /*!
     117              :  * \brief Call
     118              :  * `fn(get<Callable::return_tags>(return_args)...,
     119              :  * get<Callable::argument_tags>(args...))`
     120              :  */
     121              : template <typename Callable, typename T, typename... Args>
     122            1 : auto invoke(const gsl::not_null<T*> return_args, Callable&& fn,
     123              :             const Args&... args) {
     124              :   return detail::invoke_impl(return_args, typename Callable::return_tags{},
     125              :                              typename Callable::argument_tags{},
     126              :                              std::forward<Callable>(fn), args...);
     127              : }