childaccess.hh

// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=8 sw=2 sts=2:
// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception OR LGPL-3.0-or-later
 
#ifndef DUNE_COMMON_TYPETREE_CHILDACCESS_HH
#define DUNE_COMMON_TYPETREE_CHILDACCESS_HH
 
#include <cstddef>
#include <type_traits>
#include <utility>
#include <tuple>
 
#include <dune/common/indices.hh>
#include <dune/common/typelist.hh>
#include <dune/common/typetraits.hh>
 
#include <dune/common/hybridmultiindex.hh>
#include <dune/common/typetree/nodeconcepts.hh>
#include <dune/common/typetree/treepath.hh>
 
 
namespace Dune::TypeTree {
 
 
 
  template<typename Node, typename... Indices>
  decltype(auto) child (Node&& node, TreePath<Indices...> treePath)
  {
    if constexpr (sizeof...(Indices) == 0)
      return std::forward<Node>(node);
    else
    {
      using I0 = std::tuple_element_t<0, TreePath<Indices...>>;
      if constexpr (Dune::IsIntegralConstant<I0>::value and Concept::StaticDegreeInnerTreeNode<Node>)
        static_assert(I0::value < std::decay_t<Node>::degree(), "Child index out of range");
      else
        assert(std::size_t(treePath.front()) < node.degree() && "Child index out of range");
      if constexpr (sizeof...(Indices) == 1)
        return node.child(treePath.front());
      else
        return child(node.child(treePath.front()), pop_front(treePath));
    }
  }
 
 
  template<typename Node, typename... Indices>
  decltype(auto) child (Node&& node, Indices... indices)
  {
    return child(node, Dune::HybridMultiIndex{indices...});
  }
 
  namespace Impl {
 
    // We could directly implement Child as
    //
    //   using Child = std::decay_t<decltype(child(std::declval<Node>(), Dune::index_constant<indices>()...))>;
    //
    // but this triggers an internal compiler error in
    // gcc 11, 12, and 13 while it does work with gcc 10
    // and 14 and clang. This can be avoided by extracting
    // this into a traits class.
    template<typename Node, std::size_t... indices>
    struct ChildTraits
    {
      using type = std::decay_t<decltype(child(std::declval<Node>(), Dune::index_constant<indices>()...))>;
    };
 
  }
 
 
  template<typename Node, std::size_t... indices>
  using Child = typename Impl::ChildTraits<Node, indices...>::type;
 
 
  template<typename Node, typename TreePath>
  using ChildForTreePath = std::decay_t<decltype(child(std::declval<Node>(), std::declval<TreePath>()))>;
 
 
 
  namespace Impl {
 
    template<class N>
    static constexpr auto childTypes()
    {
      if constexpr (Dune::TypeTree::Concept::StaticDegreeInnerTreeNode<N>)
      {
        return Dune::unpackIntegerSequence([&](auto... i) {
          return Dune::MetaType<std::tuple<Dune::TypeTree::Child<N, i>...>>{};
        }, std::make_index_sequence<N::degree()>{});
      }
      else
        return Dune::MetaType<void>{};
    }
 
 
    template<class N>
    using Children = typename decltype(Impl::childTypes<N>())::type;
 
  }
 
 
} //namespace Dune::TypeTree
 
#endif // DUNE_COMMON_TYPETREE_CHILDACCESS_HH