Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <cstddef>
       7              : 
       8              : #include "Utilities/TMPL.hpp"
       9              : 
      10              : /// \cond
      11              : template <size_t Dim, typename TagsList>
      12              : class BoundaryVariables;
      13              : template <typename TagsList>
      14              : class Variables;
      15              : namespace db {
      16              : struct PrefixTag;
      17              : struct SimpleTag;
      18              : }  // namespace db
      19              : 
      20              : namespace Tags {
      21              : template <size_t Dim, typename TagsList>
      22              : struct BoundaryVariables;
      23              : template <typename TagsList>
      24              : struct Variables;
      25              : }  // namespace Tags
      26              : /// \endcond
      27              : 
      28              : namespace db {
      29              : 
      30              : /// \ingroup DataBoxTagsGroup
      31              : /// \brief Create a new `tmpl::list` of tags by wrapping each tag in `TagList`
      32              : /// in `Wrapper<_, Args...>`.
      33              : template <template <typename...> class Wrapper, typename TagList,
      34              :           typename... Args>
      35            1 : using wrap_tags_in =
      36              :     tmpl::transform<TagList, tmpl::bind<Wrapper, tmpl::_1, tmpl::pin<Args>...>>;
      37              : 
      38              : namespace detail {
      39              : template <template <typename...> class Prefix, typename Tag, typename... Args>
      40              : struct add_tag_prefix_impl {
      41              :   using type = Prefix<Tag, Args...>;
      42              : };
      43              : 
      44              : template <template <typename...> class Prefix, size_t Dim, typename TagList,
      45              :           typename... Args>
      46              : struct add_tag_prefix_impl<Prefix, Tags::BoundaryVariables<Dim, TagList>,
      47              :                            Args...> {
      48              :   using type =
      49              :       Tags::BoundaryVariables<Dim, wrap_tags_in<Prefix, TagList, Args...>>;
      50              : };
      51              : 
      52              : template <template <typename...> class Prefix, typename TagList,
      53              :           typename... Args>
      54              : struct add_tag_prefix_impl<Prefix, Tags::Variables<TagList>, Args...> {
      55              :   using type = Tags::Variables<wrap_tags_in<Prefix, TagList, Args...>>;
      56              : };
      57              : }  // namespace detail
      58              : 
      59              : /// \ingroup DataBoxTagsGroup
      60              : /// Wrap `Tag` in `Prefix<_, Args...>`, unless `Tag` is a Tags::Variables or
      61              : /// Tags::BoundaryVariables, in which case this wraps each tag in
      62              : /// `Tag::tags_list` with `Prefix<_, Args...>`.
      63              : template <template <typename...> class Prefix, typename Tag, typename... Args>
      64            1 : using add_tag_prefix =
      65              :     typename detail::add_tag_prefix_impl<Prefix, Tag, Args...>::type;
      66              : 
      67              : namespace detail {
      68              : template <typename>
      69              : struct remove_tag_prefix_impl;
      70              : 
      71              : template <typename WrappedTag, template <typename...> class Prefix,
      72              :           typename... Args>
      73              : struct remove_tag_prefix_impl<Prefix<WrappedTag, Args...>> {
      74              :   using type = WrappedTag;
      75              : };
      76              : 
      77              : template <size_t Dim, typename TagList>
      78              : struct remove_tag_prefix_impl<Tags::BoundaryVariables<Dim, TagList>> {
      79              :   using type = Tags::BoundaryVariables<
      80              :       Dim, tmpl::transform<TagList, remove_tag_prefix_impl<tmpl::_1>>>;
      81              : };
      82              : 
      83              : template <typename TagList>
      84              : struct remove_tag_prefix_impl<Tags::Variables<TagList>> {
      85              :   using type = Tags::Variables<
      86              :       tmpl::transform<TagList, remove_tag_prefix_impl<tmpl::_1>>>;
      87              : };
      88              : }  // namespace detail
      89              : 
      90              : /// \ingroup DataBoxTagsGroup
      91              : /// Remove the outer prefix from a prefixed tag `Tag`, or remove the outer
      92              : /// prefix of each tag in `Tag::tags_list` if `Tag` is a Tags::Variables or
      93              : /// Tags::BoundaryVariables.
      94              : template <typename Tag>
      95            1 : using remove_tag_prefix = typename detail::remove_tag_prefix_impl<Tag>::type;
      96              : 
      97              : namespace detail {
      98              : 
      99              : template <typename Tag>
     100              : struct remove_all_prefixes_impl {
     101              :   using type = Tag;
     102              : };
     103              : 
     104              : template <typename Tag>
     105              :   requires(std::is_base_of_v<db::PrefixTag, Tag>)
     106              : struct remove_all_prefixes_impl<Tag> {
     107              :   using type = typename remove_all_prefixes_impl<typename Tag::tag>::type;
     108              : };
     109              : 
     110              : template <size_t Dim, typename TagList>
     111              : struct remove_all_prefixes_impl<Tags::BoundaryVariables<Dim, TagList>> {
     112              :   using type = Tags::BoundaryVariables<
     113              :       Dim, tmpl::transform<TagList, remove_all_prefixes_impl<tmpl::_1>>>;
     114              : };
     115              : 
     116              : template <typename TagList>
     117              : struct remove_all_prefixes_impl<Tags::Variables<TagList>> {
     118              :   using type = Tags::Variables<
     119              :       tmpl::transform<TagList, remove_all_prefixes_impl<tmpl::_1>>>;
     120              : };
     121              : }  // namespace detail
     122              : 
     123              : /// \ingroup DataBoxTagsGroup
     124              : /// Completely remove all prefix tags from a Tag, or all prefixes from
     125              : /// the tags in `Tag::tags_list` if `Tag` is a Tags::Variables or
     126              : /// Tags::BoundaryVariables.
     127              : template <typename Tag>
     128            1 : using remove_all_prefixes =
     129              :     typename detail::remove_all_prefixes_impl<Tag>::type;
     130              : 
     131              : namespace detail {
     132              : template <template <typename...> typename Wrapper, typename T, typename... Args>
     133              : struct prefix_variables {
     134              :   using type = T;
     135              : };
     136              : 
     137              : template <template <typename...> typename Wrapper, size_t Dim, typename Tags,
     138              :           typename... Args>
     139              : struct prefix_variables<Wrapper, BoundaryVariables<Dim, Tags>, Args...> {
     140              :   using type =
     141              :       BoundaryVariables<Dim, ::db::wrap_tags_in<Wrapper, Tags, Args...>>;
     142              : };
     143              : 
     144              : template <template <typename...> typename Wrapper, typename Tags,
     145              :           typename... Args>
     146              : struct prefix_variables<Wrapper, Variables<Tags>, Args...> {
     147              :   using type = Variables<::db::wrap_tags_in<Wrapper, Tags, Args...>>;
     148              : };
     149              : }  // namespace detail
     150              : 
     151              : /// \ingroup DataBoxTagsGroup
     152              : /// \brief Add a prefix to all tags in a Variables or BoundaryVariables,
     153              : /// leaving the argument unchanged if it is not one of those types.
     154              : ///
     155              : /// \see unprefix_variables, wrap_tags_in
     156              : template <template <typename...> class Wrapper, typename T, typename... Args>
     157            1 : using prefix_variables =
     158              :     typename detail::prefix_variables<Wrapper, T, Args...>::type;
     159              : 
     160              : namespace detail {
     161              : template <typename T>
     162              : struct unprefix_variables {
     163              :   using type = T;
     164              : };
     165              : 
     166              : template <size_t Dim, typename... Tags>
     167              : struct unprefix_variables<BoundaryVariables<Dim, tmpl::list<Tags...>>> {
     168              :   using type = BoundaryVariables<Dim, tmpl::list<tmpl::front<Tags>...>>;
     169              : };
     170              : 
     171              : template <typename... Tags>
     172              : struct unprefix_variables<Variables<tmpl::list<Tags...>>> {
     173              :   using type = Variables<tmpl::list<tmpl::front<Tags>...>>;
     174              : };
     175              : }  // namespace detail
     176              : 
     177              : /// \ingroup DataBoxTagsGroup
     178              : /// \brief Remove the outer prefix from all tags in a Variables or
     179              : /// BoundaryVariables, leaving the argument unchanged if it is not one of
     180              : /// those types.
     181              : ///
     182              : /// \see prefix_variables
     183              : template <typename T>
     184            1 : using unprefix_variables = typename detail::unprefix_variables<T>::type;
     185              : }  // namespace db