"Fossies" - the Fresh Open Source Software Archive

Member "dune-typetree-2.8.0/dune/typetree/childextraction.hh" (31 Aug 2021, 10642 Bytes) of package /linux/misc/dune/dune-typetree-2.8.0.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "childextraction.hh" see the Fossies "Dox" file reference documentation.

    1 // -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
    2 // vi: set et ts=8 sw=2 sts=2:
    3 
    4 #ifndef DUNE_TYPETREE_CHILDEXTRACTION_HH
    5 #define DUNE_TYPETREE_CHILDEXTRACTION_HH
    6 
    7 #include <type_traits>
    8 #include <utility>
    9 
   10 #include <dune/common/concept.hh>
   11 #include <dune/common/documentation.hh>
   12 #include <dune/common/typetraits.hh>
   13 #include <dune/common/shared_ptr.hh>
   14 
   15 #include <dune/typetree/nodeinterface.hh>
   16 #include <dune/typetree/treepath.hh>
   17 
   18 
   19 namespace Dune {
   20   namespace TypeTree {
   21 
   22     //! \addtogroup TypeTreeChildExtraction Child Extraction
   23     //! Utility functions and metafunctions for extracting children from a TypeTree.
   24     //! \ingroup TypeTree
   25     //! \{
   26 
   27 #ifndef DOXYGEN
   28 
   29     namespace Impl {
   30 
   31       // check at run time whether index is a valid child index
   32       template <class Node, class Index>
   33       std::true_type checkChildIndex (Node const& node, Index i)
   34       {
   35         assert(std::size_t(i) < node.degree() && "Child index out of range");
   36         return {};
   37       }
   38 
   39       // check at compile time whether index is a valid index
   40       template <class Node, std::size_t i>
   41       std::bool_constant<(i < Node::degree())> checkChildIndex (Node const& node, index_constant<i>)
   42       {
   43         static_assert(i < Node::degree(), "Child index out of range");
   44         return {};
   45       }
   46 
   47       // finally return the node itself if no further indices are provided. Break condition
   48       // for the recursion over the node childs.
   49       template<class Node>
   50       decltype(auto) childImpl (Node&& node)
   51       {
   52         return std::forward<Node>(node);
   53       }
   54 
   55       template<class NodePtr>
   56       auto childStorageImpl (NodePtr&& nodePtr)
   57       {
   58         return std::forward<NodePtr>(nodePtr);
   59       }
   60 
   61       // recursively call `node.child(...)` with the given indices
   62       template<class Node, class I0, class... I>
   63       decltype(auto) childImpl (Node&& node, I0 i0, I... i)
   64       {
   65         auto valid = checkChildIndex(node,i0);
   66         if constexpr (valid)
   67           return childImpl(node.child(i0),i...);
   68         else
   69           return;
   70       }
   71 
   72       // recursively call `node.childStorage(...)` with the given indices
   73       template<class NodePtr, class I0, class... I>
   74       decltype(auto) childStorageImpl (NodePtr&& nodePtr, I0 i0, I... i)
   75       {
   76         auto valid = checkChildIndex(*nodePtr,i0);
   77         if constexpr (valid)
   78           return childStorageImpl(nodePtr->childStorage(i0),i...);
   79         else
   80           return;
   81       }
   82 
   83       // forward to the impl methods by extracting the indices from the treepath
   84       template<class Node, class... Indices, std::size_t... i>
   85       decltype(auto) child (Node&& node, HybridTreePath<Indices...> tp, std::index_sequence<i...>)
   86       {
   87         return childImpl(std::forward<Node>(node),treePathEntry<i>(tp)...);
   88       }
   89 
   90       // forward to the impl methods by extracting the indices from the treepath
   91       template<class NodePtr, class... Indices, std::size_t... i>
   92       decltype(auto) childStorage (NodePtr&& nodePtr, HybridTreePath<Indices...> tp, std::index_sequence<i...>)
   93       {
   94         return childStorageImpl(std::forward<NodePtr>(nodePtr),treePathEntry<i>(tp)...);
   95       }
   96 
   97     } // end namespace Impl
   98 
   99 #endif // DOXYGEN
  100 
  101     //! Extracts the child of a node given by a sequence of compile-time and run-time indices.
  102     /**
  103      * Use this function to extract a (possibly indirect) child of a TypeTree node.
  104      *
  105      * Example:
  106      *
  107      * \code{.cc}
  108      * using namespace Dune::Indices;   // for compile-time indices
  109      * auto&& c = child(node,_4,2,_0,1);
  110      * \endcode
  111      *
  112      * returns the second child of the first child of the third child
  113      * of the fifth child of node, where some child lookups were done using
  114      * a compile-time index and some using a run-time index.
  115      *
  116      * \param node        The node from which to extract the child.
  117      * \param indices...  A list of indices that describes the path into the tree to the
  118      *                    wanted child. These parameters can be a combination of run time indices
  119      *                    (for tree nodes that allow accessing their children using run time information,
  120      *                    like PowerNode) and instances of index_constant, which work for all types of inner
  121      *                    nodes.
  122      * \return            A reference to the child, its cv-qualification depends on the passed-in node.
  123      */
  124     template<typename Node, typename... Indices>
  125 #ifdef DOXYGEN
  126     ImplementationDefined child (Node&& node, Indices... indices)
  127 #else
  128     decltype(auto) child (Node&& node, Indices... indices)
  129 #endif
  130     {
  131       return Impl::childImpl(std::forward<Node>(node),indices...);
  132     }
  133 
  134     template<typename Node, typename... Indices>
  135 #ifdef DOXYGEN
  136     ImplementationDefined childStorage (Node&& node, Indices... indices)
  137 #else
  138     auto childStorage (Node&& node, Indices... indices)
  139 #endif
  140     {
  141       static_assert(sizeof...(Indices) > 0, "childStorage() cannot be called with an empty list of child indices");
  142       return Impl::childStorageImpl(&node,indices...);
  143     }
  144 
  145     //! Extracts the child of a node given by a HybridTreePath object.
  146     /**
  147      * Use this function to extract a (possibly indirect) child of a TypeTree node.
  148      *
  149      * Example:
  150      *
  151      * \code{.cc}
  152      * using namespace Dune::TypeTree::Indices; // for compile-time indices
  153      * auto tp = Dune::TypeTree::hybridTreePath(_4,2,_0,1);
  154      * auto&& c = child(node,tp);
  155      * \endcode
  156      *
  157      * returns the second child of the first child of the third child
  158      * of the fifth child of node, where some child lookups were done using
  159      * a compile-time index and some using a run-time index.
  160      *
  161      * \param node        The node from which to extract the child.
  162      * \param tree{ath    A HybridTreePath that describes the path into the tree to the
  163      *                    wanted child. This tree path object  can be a combination of run time indices
  164      *                    (for tree nodes that allow accessing their children using run time information,
  165      *                    like PowerNode) and instances of index_constant, which work for all types of inner
  166      *                    nodes.
  167      * \return            A reference to the child, its cv-qualification depends on the passed-in node.
  168      */
  169     template<typename Node, typename... Indices>
  170 #ifdef DOXYGEN
  171     ImplementationDefined child (Node&& node, HybridTreePath<Indices...> treePath)
  172 #else
  173     decltype(auto) child (Node&& node, HybridTreePath<Indices...> tp)
  174 #endif
  175     {
  176       return Impl::child(std::forward<Node>(node),tp,std::index_sequence_for<Indices...>{});
  177     }
  178 
  179     template<typename Node, typename... Indices>
  180 #ifdef DOXYGEN
  181     ImplementationDefined child (Node&& node, HybridTreePath<Indices...> treePath)
  182 #else
  183     auto childStorage (Node&& node, HybridTreePath<Indices...> tp)
  184 #endif
  185     {
  186       static_assert(sizeof...(Indices) > 0, "childStorage() cannot be called with an empty TreePath");
  187       return Impl::childStorage(&node,tp,std::index_sequence_for<Indices...>{});
  188     }
  189 
  190 
  191 #ifndef DOXYGEN
  192 
  193     namespace impl {
  194 
  195       template<typename T>
  196       struct filter_void
  197       {
  198         using type = T;
  199       };
  200 
  201       template<>
  202       struct filter_void<void>
  203       {};
  204 
  205       template<typename Node, std::size_t... indices>
  206       struct _Child
  207         : public filter_void<std::decay_t<decltype(child(std::declval<Node>(),index_constant<indices>{}...))>>
  208       {};
  209 
  210     }
  211 
  212 #endif // DOXYGEN
  213 
  214     //! Template alias for the type of a child node given by a list of child indices.
  215     /**
  216      * This template alias is implemented in terms of the free-standing child() functions and uses those
  217      * in combination with decltype() to extract the child type.
  218 
  219      * \tparam Node     The type of the parent node.
  220      * \tparam indices  A list of index values the describes the path to the wanted child.
  221      */
  222     template<typename Node, std::size_t... indices>
  223     using Child = typename impl::_Child<Node,indices...>::type;
  224 
  225 
  226 #ifndef DOXYGEN
  227 
  228     namespace impl {
  229 
  230       template<typename Node, typename TreePath>
  231       struct _ChildForTreePath
  232       {
  233         using type = typename std::decay<decltype(child(std::declval<Node>(),std::declval<TreePath>()))>::type;
  234       };
  235 
  236     }
  237 
  238 #endif // DOXYGEN
  239 
  240     //! Template alias for the type of a child node given by a TreePath or a HybridTreePath type.
  241     /**
  242      * This template alias is implemented in terms of the free-standing child() functions and uses those
  243      * in combination with decltype() to extract the child type. It supports both TreePath and
  244      * HybridTreePath.
  245      *
  246      * \tparam Node      The type of the parent node.
  247      * \tparam TreePath  The type of a TreePath or a HybridTreePath that describes the path to the wanted child.
  248      */
  249     template<typename Node, typename TreePath>
  250     using ChildForTreePath = typename impl::_ChildForTreePath<Node,TreePath>::type;
  251 
  252 
  253 #ifndef DOXYGEN
  254 
  255     namespace impl {
  256 
  257       // By default, types are flat indices if they are integral
  258       template<typename T>
  259       struct _is_flat_index
  260       {
  261         using type = std::is_integral<T>;
  262       };
  263 
  264       // And so is any index_constant
  265       template<std::size_t i>
  266       struct _is_flat_index<index_constant<i>>
  267       {
  268         using type = std::true_type;
  269       };
  270 
  271     }
  272 
  273 #endif // DOXYGEN
  274 
  275     //! Type trait that determines whether T is a flat index in the context of child extraction.
  276     /*
  277      * This type trait can be used to check whether T is a flat index (i.e. either `std::size_t`
  278      * or `index_constant`). The type trait normalizes T before doing the check, so it will also
  279      * work correctly for references and cv-qualified types.
  280      */
  281     template<typename T>
  282     using is_flat_index = typename impl::_is_flat_index<std::decay_t<T>>::type;
  283 
  284 #ifndef DOXYGEN
  285 
  286     namespace impl {
  287 
  288       // helper function for check in member child() functions that tolerates being passed something that
  289       // isn't a TreePath. It will just return 0 in that case
  290 
  291       template<typename T>
  292       constexpr typename std::enable_if<
  293         Dune::TypeTree::is_flat_index<T>::value,
  294         bool
  295         >::type
  296       _non_empty_tree_path (T)
  297       {
  298         return false;
  299       }
  300 
  301       template<typename T>
  302       constexpr typename std::enable_if<
  303         !Dune::TypeTree::is_flat_index<T>::value,
  304         bool
  305         >::type
  306       _non_empty_tree_path (T t)
  307       {
  308         return treePathSize(t) > 0;
  309       }
  310 
  311     }
  312 
  313 #endif // DOXYGEN
  314 
  315     //! \} group TypeTree
  316 
  317   } // namespace TypeTree
  318 } //namespace Dune
  319 
  320 #endif // DUNE_TYPETREE_CHILDEXTRACTION_HH