Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <memory>
       7             : #include <type_traits>
       8             : 
       9             : #include "DataStructures/DataBox/MetavariablesTag.hpp"
      10             : #include "DataStructures/DataBox/TagTraits.hpp"
      11             : #include "Utilities/NoSuchType.hpp"
      12             : #include "Utilities/TMPL.hpp"
      13             : #include "Utilities/TypeTraits/IsA.hpp"
      14             : 
      15           1 : namespace Tags {
      16             : /*!
      17             :  * \ingroup DataBoxTagsGroup
      18             :  * \brief Tag used to retrieve the DataBox from the `db::get` function
      19             :  *
      20             :  * The main use of this tag is to allow fetching the DataBox from itself. The
      21             :  * primary use case is to allow an invokable to take a DataBox as an argument
      22             :  * when called through `db::apply`.
      23             :  *
      24             :  * \snippet Test_DataBox.cpp databox_self_tag_example
      25             :  */
      26           1 : struct DataBox {
      27             :   // Trick to get friend function declaration to compile but a const
      28             :   // NoSuchtype****& is rather useless
      29           0 :   using type = NoSuchType****;
      30             : };
      31             : }  // namespace Tags
      32             : 
      33             : namespace db {
      34             : 
      35             : namespace detail {
      36             : template <typename TagsList,
      37             :           typename MatchingTagsList = tmpl::filter<
      38             :               TagsList, tt::is_a<Parallel::Tags::MetavariablesImpl, tmpl::_1>>>
      39             : struct metavars_tag_impl {
      40             :   static_assert(tmpl::size<MatchingTagsList>::value == 1);
      41             :   using type = tmpl::front<MatchingTagsList>;
      42             : };
      43             : 
      44             : template <typename TagsList>
      45             : struct metavars_tag_impl<TagsList, tmpl::list<>> {
      46             :   using type = NoSuchType;
      47             : };
      48             : 
      49             : template <typename TagList, typename Tag>
      50             : using list_of_matching_tags = tmpl::conditional_t<
      51             :     std::is_same_v<Tag, ::Tags::DataBox>, tmpl::list<::Tags::DataBox>,
      52             :     tmpl::conditional_t<
      53             :         std::is_same_v<Tag, Parallel::Tags::Metavariables>,
      54             :         tmpl::list<Parallel::Tags::Metavariables>,
      55             :         tmpl::filter<TagList, std::is_base_of<tmpl::pin<Tag>, tmpl::_1>>>>;
      56             : 
      57             : template <typename Tag, typename TagList,
      58             :           typename MatchingTagsList = list_of_matching_tags<TagList, Tag>>
      59             : struct first_matching_tag_impl {
      60             :   using type = tmpl::front<MatchingTagsList>;
      61             : };
      62             : 
      63             : template <typename Tag, typename TagList>
      64             : struct first_matching_tag_impl<Tag, TagList, tmpl::list<>> {
      65             :   static_assert(std::is_same<Tag, NoSuchType>::value,
      66             :                 "Could not find the DataBox tag in the list of DataBox tags. "
      67             :                 "The first template parameter of 'first_matching_tag_impl' is "
      68             :                 "the tag that cannot be found and the second is the list of "
      69             :                 "tags being searched.");
      70             :   using type = NoSuchType;
      71             : };
      72             : 
      73             : template <typename TagList, typename Tag>
      74             : using first_matching_tag = typename first_matching_tag_impl<Tag, TagList>::type;
      75             : 
      76             : template <typename TagList, typename Tag>
      77             : constexpr auto number_of_matching_tags =
      78             :     tmpl::size<list_of_matching_tags<TagList, Tag>>::value;
      79             : 
      80             : template <typename TagList, typename Tag>
      81             : struct has_unique_matching_tag
      82             :     : std::integral_constant<bool, number_of_matching_tags<TagList, Tag> == 1> {
      83             : };
      84             : 
      85             : template <typename TagList, typename Tag>
      86             : using has_unique_matching_tag_t =
      87             :     typename has_unique_matching_tag<TagList, Tag>::type;
      88             : 
      89             : template <typename TagList, typename Tag>
      90             : constexpr bool has_unique_matching_tag_v =
      91             :     has_unique_matching_tag<TagList, Tag>::value;
      92             : 
      93             : template <typename TagList, typename Tag>
      94             : struct has_no_matching_tag
      95             :     : std::integral_constant<bool, number_of_matching_tags<TagList, Tag> == 0> {
      96             : };
      97             : 
      98             : template <typename TagList, typename Tag>
      99             : using has_no_matching_tag_t = typename has_no_matching_tag<TagList, Tag>::type;
     100             : 
     101             : template <typename TagList, typename Tag>
     102             : constexpr bool has_no_matching_tag_v = has_no_matching_tag<TagList, Tag>::value;
     103             : 
     104             : template <typename T>
     105             : struct ConvertToConst {
     106             :   using type = const T&;
     107             : };
     108             : 
     109             : template <typename T>
     110             : struct ConvertToConst<std::unique_ptr<T>> {
     111             :   using type = const T&;
     112             : };
     113             : 
     114             : template <typename Tag, typename TagsList>
     115             : struct const_item_type_impl {
     116             :   using type = typename db::detail::ConvertToConst<
     117             :       std::decay_t<typename Tag::type>>::type;
     118             : };
     119             : 
     120             : template <typename TagsList>
     121             : struct const_item_type_impl<Parallel::Tags::Metavariables, TagsList> {
     122             :   using type = const typename detail::metavars_tag_impl<TagsList>::type::type&;
     123             : };
     124             : }  // namespace detail
     125             : 
     126             : template <typename Tag, typename TagsList>
     127           0 : using const_item_type =
     128             :     typename detail::const_item_type_impl<Tag, TagsList>::type;
     129             : }  // namespace db