Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <string>
       7             : #include <tuple>
       8             : 
       9             : #include "DataStructures/DataBox/DataBoxTag.hpp"
      10             : #include "DataStructures/DataBox/IsApplyCallable.hpp"
      11             : #include "DataStructures/DataBox/TagName.hpp"
      12             : #include "Utilities/CleanupRoutine.hpp"
      13             : #include "Utilities/ErrorHandling/Error.hpp"
      14             : #include "Utilities/ForceInline.hpp"
      15             : #include "Utilities/Gsl.hpp"
      16             : #include "Utilities/PrettyType.hpp"
      17             : #include "Utilities/TMPL.hpp"
      18             : #include "Utilities/TypeTraits/IsCallable.hpp"
      19             : 
      20           1 : namespace db {
      21             : /*!
      22             :  * \brief A class for retrieving items from a DataBox without needing to know
      23             :  * all the tags in the box.
      24             :  *
      25             :  * Retrieval is handled using a virtual function call but still uses Tags
      26             :  * rather than strings to ensure automatic handling of casting to the expected
      27             :  * type.
      28             :  */
      29           1 : class Access {
      30             :  public:
      31           0 :   virtual ~Access() = default;
      32             : 
      33             :   /// Print the expanded type aliases of the derived `db::DataBox`
      34           1 :   virtual std::string print_tags() const = 0;
      35             : 
      36             :   /// Print the expanded type aliases of the derived `db::DataBox`
      37           1 :   virtual std::string print_types() const = 0;
      38             : 
      39             :  private:
      40             :   template <typename Tag>
      41           1 :   friend const auto& get(const Access& box);
      42             :   template <typename... MutateTags, typename Invokable, typename... Args>
      43           0 :   friend decltype(auto) mutate(Invokable&& invokable,
      44             :                                gsl::not_null<Access*> box, Args&&... args);
      45           0 :   virtual void* mutate_item_by_name(const std::string& tag_name) = 0;
      46           0 :   virtual const void* get_item_by_name(const std::string& tag_name) const = 0;
      47           0 :   virtual bool lock_box_for_mutate() = 0;
      48           0 :   virtual void unlock_box_after_mutate() = 0;
      49           0 :   virtual void mutate_mutable_subitems(const std::string& tag_name) = 0;
      50           0 :   virtual void reset_compute_items_after_mutate(
      51             :       const std::string& tag_name) = 0;
      52             : 
      53             :   template <typename Tag>
      54           0 :   auto mutate() -> gsl::not_null<typename Tag::type*> {
      55             :     static const std::string tag_name = pretty_type::get_name<Tag>();
      56             :     return {
      57             :         // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
      58             :         reinterpret_cast<typename Tag::type*>(mutate_item_by_name(tag_name))};
      59             :   }
      60             : };
      61             : 
      62             : /// \brief Retrieve a tag from a `db::Access`
      63             : template <typename Tag>
      64           1 : SPECTRE_ALWAYS_INLINE const auto& get(const Access& box) {
      65             :   static const std::string tag_name = pretty_type::get_name<Tag>();
      66             :   if constexpr (tt::is_a_v<std::unique_ptr, typename Tag::type>) {
      67             :     // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
      68             :     return *reinterpret_cast<const typename Tag::type::element_type*>(
      69             :         box.get_item_by_name(tag_name));
      70             :   } else {
      71             :     // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
      72             :     return *reinterpret_cast<const typename Tag::type*>(
      73             :         box.get_item_by_name(tag_name));
      74             :   }
      75             : }
      76             : 
      77             : /// \brief Mutate a tag in a `db::Access`.
      78             : template <typename... MutateTags, typename Invokable, typename... Args>
      79           1 : decltype(auto) mutate(Invokable&& invokable, const gsl::not_null<Access*> box,
      80             :                       Args&&... args) {
      81             :   if (UNLIKELY(box->lock_box_for_mutate())) {
      82             :     ERROR(
      83             :         "Unable to mutate a DataBox that is already being mutated. This "
      84             :         "error occurs when mutating a DataBox from inside the invokable "
      85             :         "passed to the mutate function.");
      86             :   }
      87             : 
      88             :   const CleanupRoutine unlock_box = [&box]() {
      89             :     box->unlock_box_after_mutate();
      90             :   };
      91             : 
      92             :   // Check that the arguments are fetchable before setting up the
      93             :   // cleanup so we don't trigger an error during stack unwinding.
      94             :   const std::tuple mutate_pointers{box->template mutate<MutateTags>()...};
      95             : 
      96             :   const CleanupRoutine reset_post_mutate = [&box]() {
      97             :     (void)box;
      98             :     EXPAND_PACK_LEFT_TO_RIGHT([&box]() {
      99             :       static const std::string tag_name = pretty_type::get_name<MutateTags>();
     100             :       box->mutate_mutable_subitems(tag_name);
     101             :       box->reset_compute_items_after_mutate(tag_name);
     102             :     }());
     103             :   };
     104             :   return std::apply(
     105             :       invokable,
     106             :       std::tuple_cat(mutate_pointers,
     107             :                      std::forward_as_tuple(std::forward<Args>(args)...)));
     108             : }
     109             : 
     110             : namespace detail {
     111             : template <typename... ReturnTags, typename... ArgumentTags, typename F,
     112             :           typename... Args>
     113             : SPECTRE_ALWAYS_INLINE constexpr decltype(auto) mutate_apply(
     114             :     F&& f, const gsl::not_null<Access*> box, tmpl::list<ReturnTags...> /*meta*/,
     115             :     tmpl::list<ArgumentTags...> /*meta*/, Args&&... args) {
     116             :   static_assert(not(... or std::is_same_v<ArgumentTags, Tags::DataBox>),
     117             :                 "Cannot pass Tags::DataBox to mutate_apply when mutating "
     118             :                 "since the db::get won't work inside mutate_apply.");
     119             :   if constexpr (detail::is_apply_callable_v<
     120             :                     F, const gsl::not_null<typename ReturnTags::type*>...,
     121             :                     const_item_type<ArgumentTags, tmpl::list<>>..., Args...>) {
     122             :     return ::db::mutate<ReturnTags...>(
     123             :         [](const gsl::not_null<typename ReturnTags::type*>... mutated_items,
     124             :            const_item_type<ArgumentTags, tmpl::list<>>... args_items,
     125             :            decltype(std::forward<Args>(args))... l_args) {
     126             :           return std::decay_t<F>::apply(mutated_items..., args_items...,
     127             :                                         std::forward<Args>(l_args)...);
     128             :         },
     129             :         box, db::get<ArgumentTags>(*box)..., std::forward<Args>(args)...);
     130             :   } else if constexpr (::tt::is_callable_v<
     131             :                            F,
     132             :                            const gsl::not_null<typename ReturnTags::type*>...,
     133             :                            const_item_type<ArgumentTags, tmpl::list<>>...,
     134             :                            Args...>) {
     135             :     return ::db::mutate<ReturnTags...>(f, box, db::get<ArgumentTags>(*box)...,
     136             :                                        std::forward<Args>(args)...);
     137             :   } else {
     138             :     error_function_not_callable<F, gsl::not_null<typename ReturnTags::type*>...,
     139             :                                 const_item_type<ArgumentTags, tmpl::list<>>...,
     140             :                                 Args...>();
     141             :   }
     142             : }
     143             : }  // namespace detail
     144             : 
     145             : /// @{
     146             : /*!
     147             :  * \ingroup DataBoxGroup
     148             :  * \brief Apply the invokable `f` mutating items `MutateTags` and taking as
     149             :  * additional arguments `ArgumentTags` and `args`.
     150             :  *
     151             :  * \details
     152             :  * `f` must either be invokable with the arguments of type
     153             :  * `gsl::not_null<db::item_type<MutateTags>*>...,
     154             :  * db::const_item_type<ArgumentTags>..., Args...`
     155             :  * where the first two pack expansions are over the elements in the typelists
     156             :  * `MutateTags` and `ArgumentTags`, or have a static `apply` function that is
     157             :  * callable with the same types. If the type of `f` specifies `return_tags` and
     158             :  * `argument_tags` typelists, these are used for the `MutateTags` and
     159             :  * `ArgumentTags`, respectively.
     160             :  *
     161             :  * Any return values of the invokable `f` are forwarded as returns to the
     162             :  * `mutate_apply` call.
     163             :  *
     164             :  * \example
     165             :  * An example of using `mutate_apply` with a lambda:
     166             :  * \snippet Test_DataBox.cpp mutate_apply_lambda_example
     167             :  *
     168             :  * An example of a class with a static `apply` function
     169             :  * \snippet Test_DataBox.cpp mutate_apply_struct_definition_example
     170             :  * and how to use `mutate_apply` with the above class
     171             :  * \snippet Test_DataBox.cpp mutate_apply_struct_example_stateful
     172             :  * Note that the class exposes `return_tags` and `argument_tags` typelists, so
     173             :  * we don't specify the template parameters explicitly.
     174             :  * If the class `F` has no state, like in this example,
     175             :  * \snippet Test_DataBox.cpp mutate_apply_struct_definition_example
     176             :  * you can also use the stateless overload of `mutate_apply`:
     177             :  * \snippet Test_DataBox.cpp mutate_apply_struct_example_stateless
     178             :  *
     179             :  * \tparam MutateTags typelist of Tags to mutate
     180             :  * \tparam ArgumentTags typelist of additional items to retrieve from the
     181             :  * `Access`
     182             :  * \tparam F The invokable to apply
     183             :  */
     184             : template <typename MutateTags, typename ArgumentTags, typename F,
     185             :           typename... Args>
     186           1 : SPECTRE_ALWAYS_INLINE constexpr decltype(auto) mutate_apply(
     187             :     F&& f, const gsl::not_null<Access*> box, Args&&... args) {
     188             :   return detail::mutate_apply(std::forward<F>(f), box, MutateTags{},
     189             :                               ArgumentTags{}, std::forward<Args>(args)...);
     190             : }
     191             : 
     192             : template <typename F, typename... Args>
     193           1 : SPECTRE_ALWAYS_INLINE constexpr decltype(auto) mutate_apply(
     194             :     F&& f, const gsl::not_null<Access*> box, Args&&... args) {
     195             :   return mutate_apply<typename std::decay_t<F>::return_tags,
     196             :                       typename std::decay_t<F>::argument_tags>(
     197             :       std::forward<F>(f), box, std::forward<Args>(args)...);
     198             : }
     199             : 
     200             : template <typename F, typename... Args>
     201           1 : SPECTRE_ALWAYS_INLINE constexpr decltype(auto) mutate_apply(
     202             :     const gsl::not_null<Access*> box, Args&&... args) {
     203             :   return mutate_apply(F{}, box, std::forward<Args>(args)...);
     204             : }
     205             : /// @}
     206             : }  // namespace db