#include <dune/common/typetraits.hh>│ │ │ │ -
#include <dune/typetree/nodeinterface.hh>│ │ │ │ -
#include <dune/typetree/nodetags.hh>│ │ │ │ -
#include <dune/typetree/treepath.hh>│ │ │ │ -
#include <dune/typetree/utility.hh>│ │ │ │ +
#include <dune/typetree/traversal.hh>│ │ │ │
Go to the source code of this file.
│ │ │ ││ │ │ │ -Classes | |
| struct | Dune::TypeTree::or_< result_type > |
| Statically combine two values of type result_type using ||. More... | |
| struct | Dune::TypeTree::or_< result_type >::reduce< r1, r2 > |
| struct | Dune::TypeTree::and_< result_type > |
| Statically combine two values of type result_type using &&. More... | |
| struct | Dune::TypeTree::and_< result_type >::reduce< r1, r2 > |
| struct | Dune::TypeTree::plus< result_type > |
| Statically combine two values of type result_type using +. More... | |
| struct | Dune::TypeTree::plus< result_type >::reduce< r1, r2 > |
| struct | Dune::TypeTree::minus< result_type > |
| Statically combine two values of type result_type using -. More... | |
| struct | Dune::TypeTree::minus< result_type >::reduce< r1, r2 > |
| struct | Dune::TypeTree::multiply< result_type > |
| Statically combine two values of type result_type using *. More... | |
| struct | Dune::TypeTree::multiply< result_type >::reduce< r1, r2 > |
| struct | Dune::TypeTree::min< result_type > |
| Statically combine two values of type result_type by returning their minimum. More... | |
| struct | Dune::TypeTree::min< result_type >::reduce< r1, r2 > |
| struct | Dune::TypeTree::max< result_type > |
| Statically combine two values of type result_type by returning their maximum. More... | |
| struct | Dune::TypeTree::max< result_type >::reduce< r1, r2 > |
| struct | Dune::TypeTree::AccumulateValue< Tree, Functor, Reduction, startValue, ParentChildReduction > |
| Statically accumulate a value over the nodes of a TypeTree. More... | |
| struct | Dune::TypeTree::TypeAccumulationPolicy< Functor, Reduction, StartType, ParentChildReduction, ReductionAlgorithm > |
| struct | Dune::TypeTree::AccumulateType< Tree, Policy > |
| Statically accumulate a type over the nodes of a TypeTree. More... | |
│ │ │ │ Namespaces | |
| namespace | Dune |
| namespace | Dune::TypeTree |
| namespace | Dune::TypeTree::Experimental |
│ │ │ │ Functions | |
| template<typename Tree , typename Visitor , typename Init > | |
| auto | Dune::TypeTree::Experimental::hybridApplyToTree (Tree &&tree, Visitor &&visitor, Init &&init) |
| Apply hybrid visitor to TypeTree. | |
| template<typename ResultType , typename Tree , typename F , typename R > | |
| ResultType | Dune::TypeTree::reduceOverLeafs (const Tree &tree, F functor, R reduction, ResultType startValue) |
| Calculate a quantity as a reduction over the leaf nodes of a TypeTree. | |
Variable Documentation
│ │ │ │ - │ │ │ │ -◆ child_result
│ │ │ │ + │ │ │ │ +◆ _functor
│ │ │ │ │ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │
│ │ │ │
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +◆ _reduction│ │ │ │ + │ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +◆ _value│ │ │ │ + │ │ │ │ +
│ │ │ │ +
│ │ │ │ +
|
│ │ │ │ - │ │ │ │ -static | │ │ │ │ -
│ │ │ │
│ │ │ │
│ │ │ │ ◆ result
│ │ │ │ + │ │ │ │ +◆ treePathType
│ │ │ │ │ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,84 +1,33 @@
│ │ │ │ │ dune-typetree 2.10
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _t_y_p_e_t_r_e_e
│ │ │ │ │ -_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ -accumulate_static.hh File Reference
│ │ │ │ │ -#include
│ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h>
│ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h>
│ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_e_e_p_a_t_h_._h_h>
│ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_u_t_i_l_i_t_y_._h_h>
│ │ │ │ │ +_N_a_m_e_s_p_a_c_e_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ +traversalutilities.hh File Reference
│ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_v_e_r_s_a_l_._h_h>
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _s_o_u_r_c_e_ _c_o_d_e_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ -CCllaasssseess
│ │ │ │ │ -struct _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_r___<_ _r_e_s_u_l_t___t_y_p_e_ _>
│ │ │ │ │ - Statically combine two values of type result_type using ||. _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_r___<_ _r_e_s_u_l_t___t_y_p_e_ _>_:_:_r_e_d_u_c_e_<_ _r_1_,_ _r_2_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_n_d___<_ _r_e_s_u_l_t___t_y_p_e_ _>
│ │ │ │ │ - Statically combine two values of type result_type using &&. _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_n_d___<_ _r_e_s_u_l_t___t_y_p_e_ _>_:_:_r_e_d_u_c_e_<_ _r_1_,_ _r_2_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_l_u_s_<_ _r_e_s_u_l_t___t_y_p_e_ _>
│ │ │ │ │ - Statically combine two values of type result_type using +. _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_l_u_s_<_ _r_e_s_u_l_t___t_y_p_e_ _>_:_:_r_e_d_u_c_e_<_ _r_1_,_ _r_2_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_i_n_u_s_<_ _r_e_s_u_l_t___t_y_p_e_ _>
│ │ │ │ │ - Statically combine two values of type result_type using -. _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_i_n_u_s_<_ _r_e_s_u_l_t___t_y_p_e_ _>_:_:_r_e_d_u_c_e_<_ _r_1_,_ _r_2_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_u_l_t_i_p_l_y_<_ _r_e_s_u_l_t___t_y_p_e_ _>
│ │ │ │ │ - Statically combine two values of type result_type using *. _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_u_l_t_i_p_l_y_<_ _r_e_s_u_l_t___t_y_p_e_ _>_:_:_r_e_d_u_c_e_<_ _r_1_,_ _r_2_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_i_n_<_ _r_e_s_u_l_t___t_y_p_e_ _>
│ │ │ │ │ - Statically combine two values of type result_type by returning their
│ │ │ │ │ - minimum. _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_i_n_<_ _r_e_s_u_l_t___t_y_p_e_ _>_:_:_r_e_d_u_c_e_<_ _r_1_,_ _r_2_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_a_x_<_ _r_e_s_u_l_t___t_y_p_e_ _>
│ │ │ │ │ - Statically combine two values of type result_type by returning their
│ │ │ │ │ - maximum. _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_a_x_<_ _r_e_s_u_l_t___t_y_p_e_ _>_:_:_r_e_d_u_c_e_<_ _r_1_,_ _r_2_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_c_c_u_m_u_l_a_t_e_V_a_l_u_e_<_ _T_r_e_e_,_ _F_u_n_c_t_o_r_,_ _R_e_d_u_c_t_i_o_n_,_ _s_t_a_r_t_V_a_l_u_e_,
│ │ │ │ │ - _P_a_r_e_n_t_C_h_i_l_d_R_e_d_u_c_t_i_o_n_ _>
│ │ │ │ │ - Statically accumulate a value over the nodes of a _T_y_p_e_T_r_e_e. _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_y_p_e_A_c_c_u_m_u_l_a_t_i_o_n_P_o_l_i_c_y_<_ _F_u_n_c_t_o_r_,_ _R_e_d_u_c_t_i_o_n_,_ _S_t_a_r_t_T_y_p_e_,
│ │ │ │ │ - _P_a_r_e_n_t_C_h_i_l_d_R_e_d_u_c_t_i_o_n_,_ _R_e_d_u_c_t_i_o_n_A_l_g_o_r_i_t_h_m_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_c_c_u_m_u_l_a_t_e_T_y_p_e_<_ _T_r_e_e_,_ _P_o_l_i_c_y_ _>
│ │ │ │ │ - Statically accumulate a type over the nodes of a _T_y_p_e_T_r_e_e. _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ NNaammeessppaacceess
│ │ │ │ │ namespace _D_u_n_e
│ │ │ │ │
│ │ │ │ │ namespace _D_u_n_e_:_:_T_y_p_e_T_r_e_e
│ │ │ │ │
│ │ │ │ │ -namespace _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l
│ │ │ │ │ -
│ │ │ │ │ FFuunnccttiioonnss
│ │ │ │ │ -template
│ │ │ │ │ -auto _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_h_y_b_r_i_d_A_p_p_l_y_T_o_T_r_e_e (Tree &&tree, Visitor
│ │ │ │ │ - &&visitor, Init &&init)
│ │ │ │ │ - Apply hybrid visitor to _T_y_p_e_T_r_e_e.
│ │ │ │ │ +template
│ │ │ │ │ +ResultType _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_r_e_d_u_c_e_O_v_e_r_L_e_a_f_s (const Tree &tree, F functor, R
│ │ │ │ │ + reduction, ResultType startValue)
│ │ │ │ │ + Calculate a quantity as a reduction over the leaf nodes of a
│ │ │ │ │ + _T_y_p_e_T_r_e_e.
│ │ │ │ │
│ │ │ │ │ ********** VVaarriiaabbllee DDooccuummeennttaattiioonn **********
│ │ │ │ │ -********** _?◆_? cchhiilldd__rreessuulltt **********
│ │ │ │ │ -const result_type child_result =
│ │ │ │ │ -accumulate_value>_:_: static
│ │ │ │ │ -_r_e_s_u_l_t
│ │ │ │ │ -********** _?◆_? rreessuulltt **********
│ │ │ │ │ -const result_type result = current_value static
│ │ │ │ │ +********** _?◆_? __ffuunnccttoorr **********
│ │ │ │ │ +F _functor
│ │ │ │ │ +********** _?◆_? __rreedduuccttiioonn **********
│ │ │ │ │ +R _reduction
│ │ │ │ │ +********** _?◆_? __vvaalluuee **********
│ │ │ │ │ +ResultType _value
│ │ │ │ │ +********** _?◆_? ttrreeeePPaatthhTTyyppee **********
│ │ │ │ │ +const TreePathType::Type treePathType = TreePathType::dynamic static
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00008_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-typetree: accumulate_static.hh Source File
│ │ │ │ +dune-typetree: traversalutilities.hh Source File
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -74,595 +74,90 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
|
│ │ │ │ │ │ │ │ static | │ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ accumulate_static.hh
traversalutilities.hh
│ │ │ │ Go to the documentation of this file.
│ │ │ │ Generated by
1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,698 +1,109 @@
│ │ │ │ │ dune-typetree 2.10
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _t_y_p_e_t_r_e_e
│ │ │ │ │ -accumulate_static.hh
│ │ │ │ │ +traversalutilities.hh
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ 2// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ 3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 4// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-with-
│ │ │ │ │ PDELab-exception
│ │ │ │ │ 5
│ │ │ │ │ -6#ifndef DUNE_TYPETREE_ACCUMULATE_STATIC_HH
│ │ │ │ │ -7#define DUNE_TYPETREE_ACCUMULATE_STATIC_HH
│ │ │ │ │ +6#ifndef DUNE_TYPETREE_TRAVERSALUTILITIES_HH
│ │ │ │ │ +7#define DUNE_TYPETREE_TRAVERSALUTILITIES_HH
│ │ │ │ │ 8
│ │ │ │ │ -9#include
│ │ │ │ │ -10#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h>
│ │ │ │ │ -11#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h>
│ │ │ │ │ -12#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_e_e_p_a_t_h_._h_h>
│ │ │ │ │ -13#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_u_t_i_l_i_t_y_._h_h>
│ │ │ │ │ -14
│ │ │ │ │ -15
│ │ │ │ │ -_1_6namespace _D_u_n_e {
│ │ │ │ │ -_1_7 namespace TypeTree {
│ │ │ │ │ -18
│ │ │ │ │ -25 template
│ │ │ │ │ -_2_6 struct _o_r__
│ │ │ │ │ -27 {
│ │ │ │ │ -28 template
│ │ │ │ │ -_2_9 struct _r_e_d_u_c_e
│ │ │ │ │ +9#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_v_e_r_s_a_l_._h_h>
│ │ │ │ │ +10
│ │ │ │ │ +11namespace _D_u_n_e {
│ │ │ │ │ +12 namespace TypeTree {
│ │ │ │ │ +13
│ │ │ │ │ +19 namespace {
│ │ │ │ │ +20
│ │ │ │ │ +22
│ │ │ │ │ +27 template
│ │ │ │ │ +28 struct LeafReductionVisitor
│ │ │ │ │ +29 : public TypeTree::TreeVisitor
│ │ │ │ │ 30 {
│ │ │ │ │ -_3_1 static const result_type _r_e_s_u_l_t = r1 || r2;
│ │ │ │ │ -32 };
│ │ │ │ │ -33 };
│ │ │ │ │ -34
│ │ │ │ │ -36 template
│ │ │ │ │ -_3_7 struct _a_n_d__
│ │ │ │ │ -38 {
│ │ │ │ │ -39 template
│ │ │ │ │ -_4_0 struct _r_e_d_u_c_e
│ │ │ │ │ -41 {
│ │ │ │ │ -_4_2 static const result_type _r_e_s_u_l_t = r1 && r2;
│ │ │ │ │ -43 };
│ │ │ │ │ -44 };
│ │ │ │ │ +31
│ │ │ │ │ +_3_2 static const _T_r_e_e_P_a_t_h_T_y_p_e_:_:_T_y_p_e _t_r_e_e_P_a_t_h_T_y_p_e = _T_r_e_e_P_a_t_h_T_y_p_e_:_:_d_y_n_a_m_i_c;
│ │ │ │ │ +33
│ │ │ │ │ +34 template
│ │ │ │ │ +35 void leaf(const Node& node, TreePath _t_r_e_e_P_a_t_h)
│ │ │ │ │ +36 {
│ │ │ │ │ +37 ___v_a_l_u_e = ___r_e_d_u_c_t_i_o_n(___v_a_l_u_e,___f_u_n_c_t_o_r(node,_t_r_e_e_P_a_t_h));
│ │ │ │ │ +38 }
│ │ │ │ │ +39
│ │ │ │ │ +40 LeafReductionVisitor(F functor, R reduction, ResultType startValue)
│ │ │ │ │ +41 : ___f_u_n_c_t_o_r(functor)
│ │ │ │ │ +42 , ___r_e_d_u_c_t_i_o_n(reduction)
│ │ │ │ │ +43 , ___v_a_l_u_e(startValue)
│ │ │ │ │ +44 {}
│ │ │ │ │ 45
│ │ │ │ │ -47 template
│ │ │ │ │ -_4_8 struct _p_l_u_s
│ │ │ │ │ -49 {
│ │ │ │ │ -50 template
│ │ │ │ │ -_5_1 struct _r_e_d_u_c_e
│ │ │ │ │ -52 {
│ │ │ │ │ -_5_3 static const result_type _r_e_s_u_l_t = r1 + r2;
│ │ │ │ │ -54 };
│ │ │ │ │ -55 };
│ │ │ │ │ -56
│ │ │ │ │ -58 template
│ │ │ │ │ -_5_9 struct _m_i_n_u_s
│ │ │ │ │ -60 {
│ │ │ │ │ -61 template
│ │ │ │ │ -_6_2 struct _r_e_d_u_c_e
│ │ │ │ │ -63 {
│ │ │ │ │ -_6_4 static const result_type _r_e_s_u_l_t = r1 - r2;
│ │ │ │ │ -65 };
│ │ │ │ │ -66 };
│ │ │ │ │ -67
│ │ │ │ │ -69 template
│ │ │ │ │ -_7_0 struct _m_u_l_t_i_p_l_y
│ │ │ │ │ -71 {
│ │ │ │ │ -72 template
│ │ │ │ │ -_7_3 struct _r_e_d_u_c_e
│ │ │ │ │ -74 {
│ │ │ │ │ -_7_5 static const result_type _r_e_s_u_l_t = r1 * r2;
│ │ │ │ │ -76 };
│ │ │ │ │ -77 };
│ │ │ │ │ -78
│ │ │ │ │ -80 template
│ │ │ │ │ -_8_1 struct _m_i_n
│ │ │ │ │ -82 {
│ │ │ │ │ -83 template
│ │ │ │ │ -_8_4 struct _r_e_d_u_c_e
│ │ │ │ │ -85 {
│ │ │ │ │ -_8_6 static const result_type _r_e_s_u_l_t = r1 < r2 ? r1 : r2;
│ │ │ │ │ -87 };
│ │ │ │ │ -88 };
│ │ │ │ │ +46 ResultType _r_e_s_u_l_t() { return ___v_a_l_u_e; }
│ │ │ │ │ +47
│ │ │ │ │ +_4_8 F ___f_u_n_c_t_o_r;
│ │ │ │ │ +_4_9 R ___r_e_d_u_c_t_i_o_n;
│ │ │ │ │ +_5_0 ResultType ___v_a_l_u_e;
│ │ │ │ │ +51
│ │ │ │ │ +52 };
│ │ │ │ │ +53
│ │ │ │ │ +54 } // anonymous namespace
│ │ │ │ │ +55
│ │ │ │ │ +57
│ │ │ │ │ +82 template
│ │ │ │ │ +_8_3 ResultType _r_e_d_u_c_e_O_v_e_r_L_e_a_f_s(const Tree& tree, F functor, R reduction,
│ │ │ │ │ +ResultType startValue)
│ │ │ │ │ +84 {
│ │ │ │ │ +85 LeafReductionVisitor visitor(functor,reduction,startValue);
│ │ │ │ │ +86 _T_y_p_e_T_r_e_e_:_:_a_p_p_l_y_T_o_T_r_e_e(tree,visitor);
│ │ │ │ │ +87 return visitor.result();
│ │ │ │ │ +88 }
│ │ │ │ │ 89
│ │ │ │ │ -91 template
│ │ │ │ │ -_9_2 struct _m_a_x
│ │ │ │ │ -93 {
│ │ │ │ │ -94 template
│ │ │ │ │ -_9_5 struct _r_e_d_u_c_e
│ │ │ │ │ -96 {
│ │ │ │ │ -_9_7 static const result_type _r_e_s_u_l_t = r1 > r2 ? r1 : r2;
│ │ │ │ │ -98 };
│ │ │ │ │ -99 };
│ │ │ │ │ -100
│ │ │ │ │ -101
│ │ │ │ │ -102 namespace {
│ │ │ │ │ -103
│ │ │ │ │ -104 // implementation of the traversal algorithm
│ │ │ │ │ -105
│ │ │ │ │ -107 template
│ │ │ │ │ -108 struct accumulate_node_helper
│ │ │ │ │ -109 {
│ │ │ │ │ -110
│ │ │ │ │ -111 typedef typename Functor::result_type result_type;
│ │ │ │ │ -112
│ │ │ │ │ -_1_1_3 static const result_type _r_e_s_u_l_t = current_value;
│ │ │ │ │ -114
│ │ │ │ │ -115 };
│ │ │ │ │ -116
│ │ │ │ │ -118 template
│ │ │ │ │ -119 struct
│ │ │ │ │ -accumulate_node_helper
│ │ │ │ │ -120 {
│ │ │ │ │ -121
│ │ │ │ │ -122 typedef typename Functor::result_type result_type;
│ │ │ │ │ -123
│ │ │ │ │ -124 static const result_type _r_e_s_u_l_t = Reduction::template
│ │ │ │ │ -reduce::result>::result;
│ │ │ │ │ -125
│ │ │ │ │ -126 };
│ │ │ │ │ -127
│ │ │ │ │ -129 template
│ │ │ │ │ -130 struct accumulate_value;
│ │ │ │ │ -131
│ │ │ │ │ -133 template
│ │ │ │ │ -134 struct
│ │ │ │ │ -accumulate_value
│ │ │ │ │ -135 {
│ │ │ │ │ -136
│ │ │ │ │ -137 typedef typename Functor::result_type result_type;
│ │ │ │ │ -138
│ │ │ │ │ -139 static const result_type _r_e_s_u_l_t =
│ │ │ │ │ -140
│ │ │ │ │ -141
│ │ │ │ │ -accumulate_node_helper::value>_:_:_r_e_s_u_l_t;
│ │ │ │ │ -142
│ │ │ │ │ -143 };
│ │ │ │ │ -144
│ │ │ │ │ -146 template
│ │ │ │ │ -147 struct accumulate_over_children
│ │ │ │ │ -148 {
│ │ │ │ │ -149
│ │ │ │ │ -150 typedef typename Functor::result_type result_type;
│ │ │ │ │ -151
│ │ │ │ │ -152 typedef decltype(_p_u_s_h___b_a_c_k(TreePath{},index_constant{}))
│ │ │ │ │ -child_tree_path;
│ │ │ │ │ -153
│ │ │ │ │ -154 typedef typename Node::template _C_h_i_l_d::Type child;
│ │ │ │ │ -155
│ │ │ │ │ -_1_5_6 static const result_type child_result =
│ │ │ │ │ -accumulate_value>::
│ │ │ │ │ -result;
│ │ │ │ │ -157
│ │ │ │ │ -158 static const result_type result =
│ │ │ │ │ -accumulate_over_children::
│ │ │ │ │ -result;
│ │ │ │ │ -159
│ │ │ │ │ -160 };
│ │ │ │ │ -161
│ │ │ │ │ -163 template
│ │ │ │ │ -164 struct
│ │ │ │ │ -accumulate_over_children
│ │ │ │ │ -165 {
│ │ │ │ │ -166
│ │ │ │ │ -167 typedef typename Functor::result_type result_type;
│ │ │ │ │ -168
│ │ │ │ │ -169 static const result_type _r_e_s_u_l_t = current_value;
│ │ │ │ │ -170
│ │ │ │ │ -171 };
│ │ │ │ │ -172
│ │ │ │ │ -175 template
│ │ │ │ │ -176 struct accumulate_value_generic_composite_node
│ │ │ │ │ -177 {
│ │ │ │ │ -178
│ │ │ │ │ -179 typedef typename Functor::result_type result_type;
│ │ │ │ │ -180
│ │ │ │ │ -181 static const result_type _c_h_i_l_d___r_e_s_u_l_t =
│ │ │ │ │ -accumulate_over_children::
│ │ │ │ │ -value>_:_:_r_e_s_u_l_t;
│ │ │ │ │ -182
│ │ │ │ │ -183 static const result_type _r_e_s_u_l_t =
│ │ │ │ │ -184
│ │ │ │ │ -accumulate_node_helper::value>_:_:_r_e_s_u_l_t;
│ │ │ │ │ -185
│ │ │ │ │ -186
│ │ │ │ │ -187 };
│ │ │ │ │ -188
│ │ │ │ │ -190 template
│ │ │ │ │ -191 struct
│ │ │ │ │ -accumulate_value
│ │ │ │ │ -192 : public
│ │ │ │ │ -accumulate_value_generic_composite_node
│ │ │ │ │ -193 {};
│ │ │ │ │ -194
│ │ │ │ │ -196 template
│ │ │ │ │ -197 struct
│ │ │ │ │ -accumulate_value
│ │ │ │ │ -198 : public
│ │ │ │ │ -accumulate_value_generic_composite_node
│ │ │ │ │ -199 {};
│ │ │ │ │ -200
│ │ │ │ │ -201 } // anonymous namespace
│ │ │ │ │ -202
│ │ │ │ │ -204
│ │ │ │ │ -260 template
│ │ │ │ │ -_2_6_1 struct _A_c_c_u_m_u_l_a_t_e_V_a_l_u_e
│ │ │ │ │ -262 {
│ │ │ │ │ -263
│ │ │ │ │ -_2_6_5 typedef typename Functor::result_type _r_e_s_u_l_t___t_y_p_e;
│ │ │ │ │ -266
│ │ │ │ │ -_2_6_8 static const _r_e_s_u_l_t___t_y_p_e _r_e_s_u_l_t =
│ │ │ │ │ -accumulate_value,_N_o_d_e_T_a_g_<_T_r_e_e_>>_:_:
│ │ │ │ │ -_r_e_s_u_l_t;
│ │ │ │ │ -269
│ │ │ │ │ -270 };
│ │ │ │ │ -271
│ │ │ │ │ -274 struct flattened_reduction;
│ │ │ │ │ -275
│ │ │ │ │ -278 struct bottom_up_reduction;
│ │ │ │ │ -279
│ │ │ │ │ -280 namespace {
│ │ │ │ │ -281
│ │ │ │ │ -282 // implementation of the traversal algorithm
│ │ │ │ │ -283
│ │ │ │ │ -286 template
│ │ │ │ │ -287 struct accumulate_type_node_helper
│ │ │ │ │ -288 {
│ │ │ │ │ -289
│ │ │ │ │ -290 typedef current_type type;
│ │ │ │ │ -291
│ │ │ │ │ -292 };
│ │ │ │ │ -293
│ │ │ │ │ -295 template
│ │ │ │ │ -296 struct
│ │ │ │ │ -accumulate_type_node_helper
│ │ │ │ │ -297 {
│ │ │ │ │ -298
│ │ │ │ │ -299 typedef typename Reduction::template reduce<
│ │ │ │ │ -300 current_type,
│ │ │ │ │ -301 typename Functor::template visit<
│ │ │ │ │ -302 Node,
│ │ │ │ │ -303 TreePath
│ │ │ │ │ -304 >::type
│ │ │ │ │ -305 >::type type;
│ │ │ │ │ -306
│ │ │ │ │ -307 };
│ │ │ │ │ -308
│ │ │ │ │ -310 template
│ │ │ │ │ -311 struct accumulate_type;
│ │ │ │ │ -312
│ │ │ │ │ -314 template
│ │ │ │ │ -315 struct accumulate_type
│ │ │ │ │ -316 {
│ │ │ │ │ -317
│ │ │ │ │ -318 typedef typename accumulate_type_node_helper<
│ │ │ │ │ -319 LeafNode,
│ │ │ │ │ -320 typename Policy::functor,
│ │ │ │ │ -321 typename Policy::sibling_reduction,
│ │ │ │ │ -322 current_type,
│ │ │ │ │ -323 TreePath,
│ │ │ │ │ -324 Policy::functor::template doVisit<
│ │ │ │ │ -325 LeafNode,
│ │ │ │ │ -326 TreePath>::value
│ │ │ │ │ -327 >::type type;
│ │ │ │ │ -328
│ │ │ │ │ -329 };
│ │ │ │ │ -330
│ │ │ │ │ -331
│ │ │ │ │ -334 template
│ │ │ │ │ -335 struct propagate_type_down_tree;
│ │ │ │ │ -336
│ │ │ │ │ -338 template
│ │ │ │ │ -339 struct propagate_type_down_tree<
│ │ │ │ │ -340 current_type,
│ │ │ │ │ -341 tree_path,
│ │ │ │ │ -342 start_type,
│ │ │ │ │ -343 bottom_up_reduction
│ │ │ │ │ -344 >
│ │ │ │ │ -345 {
│ │ │ │ │ -346 typedef current_type type;
│ │ │ │ │ -347 };
│ │ │ │ │ -348
│ │ │ │ │ -350 template
│ │ │ │ │ -351 struct propagate_type_down_tree<
│ │ │ │ │ -352 current_type,
│ │ │ │ │ -353 tree_path,
│ │ │ │ │ -354 start_type,
│ │ │ │ │ -355 flattened_reduction
│ │ │ │ │ -356 >
│ │ │ │ │ -357 {
│ │ │ │ │ -358 typedef typename std::conditional<
│ │ │ │ │ -359 TreePathBack::value == 0,
│ │ │ │ │ -360 start_type,
│ │ │ │ │ -361 current_type
│ │ │ │ │ -362 >::type type;
│ │ │ │ │ -363 };
│ │ │ │ │ -364
│ │ │ │ │ -365
│ │ │ │ │ -367 template
│ │ │ │ │ -368 struct accumulate_type_over_children
│ │ │ │ │ -369 {
│ │ │ │ │ -370
│ │ │ │ │ -371 typedef decltype(_p_u_s_h___b_a_c_k(TreePath{},index_constant{}))
│ │ │ │ │ -child_tree_path;
│ │ │ │ │ -372
│ │ │ │ │ -373 typedef typename Node::template Child::Type child;
│ │ │ │ │ -374
│ │ │ │ │ -375 typedef typename accumulate_type<
│ │ │ │ │ -376 child,
│ │ │ │ │ -377 Policy,
│ │ │ │ │ -378 // apply reduction choice (flat / hierarchic)
│ │ │ │ │ -379 typename propagate_type_down_tree<
│ │ │ │ │ -380 current_type,
│ │ │ │ │ -381 child_tree_path,
│ │ │ │ │ -382 typename Policy::start_type,
│ │ │ │ │ -383 typename Policy::reduction_strategy
│ │ │ │ │ -384 >::type,
│ │ │ │ │ -385 child_tree_path,
│ │ │ │ │ -386 NodeTag
│ │ │ │ │ -387 >::type child_result_type;
│ │ │ │ │ -388
│ │ │ │ │ -389 typedef typename accumulate_type_over_children<
│ │ │ │ │ -390 Node,
│ │ │ │ │ -391 Policy,
│ │ │ │ │ -392 child_result_type,
│ │ │ │ │ -393 TreePath,
│ │ │ │ │ -394 i+1,
│ │ │ │ │ -395 n
│ │ │ │ │ -396 >::type type;
│ │ │ │ │ -397
│ │ │ │ │ -398 };
│ │ │ │ │ -399
│ │ │ │ │ -401 template
│ │ │ │ │ -402 struct accumulate_type_over_children
│ │ │ │ │ -403 {
│ │ │ │ │ -404
│ │ │ │ │ -405 typedef current_type type;
│ │ │ │ │ -406
│ │ │ │ │ -407 };
│ │ │ │ │ -408
│ │ │ │ │ -409
│ │ │ │ │ -412 template
│ │ │ │ │ -413 struct accumulate_type_generic_composite_node
│ │ │ │ │ -414 {
│ │ │ │ │ -415
│ │ │ │ │ -416 typedef typename accumulate_type_over_children<
│ │ │ │ │ -417 Node,
│ │ │ │ │ -418 Policy,
│ │ │ │ │ -419 current_type,
│ │ │ │ │ -420 TreePath,
│ │ │ │ │ -421 0,
│ │ │ │ │ -422 StaticDegree::value
│ │ │ │ │ -423 >::type children_result_type;
│ │ │ │ │ -424
│ │ │ │ │ -425 typedef typename accumulate_type_node_helper<
│ │ │ │ │ -426 Node,
│ │ │ │ │ -427 typename Policy::functor,
│ │ │ │ │ -428 typename Policy::parent_child_reduction,
│ │ │ │ │ -429 children_result_type,
│ │ │ │ │ -430 TreePath,
│ │ │ │ │ -431 Policy::functor::template doVisit<
│ │ │ │ │ -432 Node,
│ │ │ │ │ -433 TreePath
│ │ │ │ │ -434 >::value
│ │ │ │ │ -435 >::type type;
│ │ │ │ │ -436
│ │ │ │ │ -437 };
│ │ │ │ │ -438
│ │ │ │ │ -440 template
│ │ │ │ │ -441 struct accumulate_type
│ │ │ │ │ -442 : public
│ │ │ │ │ -accumulate_type_generic_composite_node
│ │ │ │ │ -443 {};
│ │ │ │ │ -444
│ │ │ │ │ -446 template
│ │ │ │ │ -447 struct
│ │ │ │ │ -accumulate_type
│ │ │ │ │ -448 : public
│ │ │ │ │ -accumulate_type_generic_composite_node
│ │ │ │ │ -449 {};
│ │ │ │ │ -450
│ │ │ │ │ -451 } // anonymous namespace
│ │ │ │ │ -452
│ │ │ │ │ -453
│ │ │ │ │ -461 template<
│ │ │ │ │ -462 typename Functor,
│ │ │ │ │ -463 typename Reduction,
│ │ │ │ │ -464 typename StartType,
│ │ │ │ │ -465 typename ParentChildReduction = Reduction,
│ │ │ │ │ -466 typename ReductionAlgorithm = flattened_reduction
│ │ │ │ │ -467 >
│ │ │ │ │ -_4_6_8 struct _T_y_p_e_A_c_c_u_m_u_l_a_t_i_o_n_P_o_l_i_c_y
│ │ │ │ │ -469 {
│ │ │ │ │ -470
│ │ │ │ │ -_4_9_8 typedef Functor _f_u_n_c_t_o_r;
│ │ │ │ │ -499
│ │ │ │ │ -_5_1_9 typedef Reduction _s_i_b_l_i_n_g___r_e_d_u_c_t_i_o_n;
│ │ │ │ │ -520
│ │ │ │ │ -_5_2_7 typedef ParentChildReduction _p_a_r_e_n_t___c_h_i_l_d___r_e_d_u_c_t_i_o_n;
│ │ │ │ │ -528
│ │ │ │ │ -_5_3_5 typedef StartType _s_t_a_r_t___t_y_p_e;
│ │ │ │ │ -536
│ │ │ │ │ -_5_4_1 typedef ReductionAlgorithm _r_e_d_u_c_t_i_o_n___s_t_r_a_t_e_g_y;
│ │ │ │ │ -542 };
│ │ │ │ │ -543
│ │ │ │ │ -544
│ │ │ │ │ -546
│ │ │ │ │ -554 template
│ │ │ │ │ -_5_5_5 struct _A_c_c_u_m_u_l_a_t_e_T_y_p_e
│ │ │ │ │ -556 {
│ │ │ │ │ -557
│ │ │ │ │ -559 typedef typename accumulate_type<
│ │ │ │ │ -560 Tree,
│ │ │ │ │ -561 Policy,
│ │ │ │ │ -562 typename Policy::start_type,
│ │ │ │ │ -563 _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_>,
│ │ │ │ │ -564 _N_o_d_e_T_a_g_<_T_r_e_e_>
│ │ │ │ │ -_5_6_5 >::type _t_y_p_e;
│ │ │ │ │ -566
│ │ │ │ │ -567 };
│ │ │ │ │ -568
│ │ │ │ │ -569
│ │ │ │ │ -570
│ │ │ │ │ -571
│ │ │ │ │ -572
│ │ │ │ │ -573 /***************************************************/
│ │ │ │ │ -574
│ │ │ │ │ -_5_7_5 namespace Experimental {
│ │ │ │ │ -576 namespace Impl {
│ │ │ │ │ -577
│ │ │ │ │ -579 template::isLeaf, int> = 0>
│ │ │ │ │ -581 auto hybridApplyToTree(T&& tree, TreePath _t_r_e_e_P_a_t_h, V&& visitor, U&&
│ │ │ │ │ -current_val)
│ │ │ │ │ -582 {
│ │ │ │ │ -583 return visitor.leaf(tree, _t_r_e_e_P_a_t_h, std::forward(current_val));
│ │ │ │ │ -584 }
│ │ │ │ │ -585
│ │ │ │ │ -587 template::isLeaf, int> = 0>
│ │ │ │ │ -589 auto hybridApplyToTree(T&& tree, TreePath _t_r_e_e_P_a_t_h, V&& visitor, U&&
│ │ │ │ │ -current_val)
│ │ │ │ │ -590 {
│ │ │ │ │ -591 using Tree = std::remove_reference_t;
│ │ │ │ │ -592 using Visitor = std::remove_reference_t;
│ │ │ │ │ -593 auto pre_val = visitor.pre(tree, _t_r_e_e_P_a_t_h, std::forward(current_val));
│ │ │ │ │ -594
│ │ │ │ │ -595 // check which type of traversal is supported by the tree
│ │ │ │ │ -596 using allowDynamicTraversal = Dune::Std::is_detected;
│ │ │ │ │ -597 using allowStaticTraversal = Dune::Std::is_detected;
│ │ │ │ │ -598
│ │ │ │ │ -599 // the tree must support either dynamic or static traversal
│ │ │ │ │ -600 static_assert(allowDynamicTraversal::value || allowStaticTraversal::value);
│ │ │ │ │ -601
│ │ │ │ │ -602 // the visitor may specify preferred dynamic traversal
│ │ │ │ │ -603 using preferDynamicTraversal = std::bool_constant;
│ │ │ │ │ -604
│ │ │ │ │ -605 // declare rule that applies visitor and current value to a child i.
│ │ │ │ │ -Returns next value
│ │ │ │ │ -606 auto apply_i = [&](auto&& value, const auto& i){
│ │ │ │ │ -607 auto&& _c_h_i_l_d = tree.child(i);
│ │ │ │ │ -608 using _C_h_i_l_d = std::decay_t;
│ │ │ │ │ -609
│ │ │ │ │ -610 auto val_before = visitor.beforeChild(tree, _c_h_i_l_d, _t_r_e_e_P_a_t_h, i, std::move
│ │ │ │ │ -(value));
│ │ │ │ │ -611
│ │ │ │ │ -612 // visits between children
│ │ │ │ │ -613 auto val_in = Hybrid::ifElse(
│ │ │ │ │ -614 Hybrid::equal_to(i,Indices::_0),
│ │ │ │ │ -615 [&](auto id){return std::move(val_before);},
│ │ │ │ │ -616 [&](auto id){return visitor.in(tree, _t_r_e_e_P_a_t_h, std::move(val_before));}
│ │ │ │ │ -617 );
│ │ │ │ │ -618
│ │ │ │ │ -619 constexpr bool visitChild = Visitor::template
│ │ │ │ │ -VisitChild::value;
│ │ │ │ │ -620 auto val_visit = [&](){
│ │ │ │ │ -621 if constexpr (visitChild) {
│ │ │ │ │ -622 auto childTreePath = _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_u_s_h___b_a_c_k(_t_r_e_e_P_a_t_h, i);
│ │ │ │ │ -623 return hybridApplyToTree(_c_h_i_l_d, childTreePath, visitor, std::move(val_in));
│ │ │ │ │ -624 }
│ │ │ │ │ -625 else
│ │ │ │ │ -626 return std::move(val_in);
│ │ │ │ │ -627 }();
│ │ │ │ │ -628
│ │ │ │ │ -629 return visitor.afterChild(tree, _c_h_i_l_d, _t_r_e_e_P_a_t_h, i, std::move(val_visit));
│ │ │ │ │ -630 };
│ │ │ │ │ -631
│ │ │ │ │ -632 // apply visitor to children
│ │ │ │ │ -633 auto in_val = [&](){
│ │ │ │ │ -634 if constexpr (allowStaticTraversal::value && not preferDynamicTraversal::
│ │ │ │ │ -value) {
│ │ │ │ │ -635 // get list of static indices
│ │ │ │ │ -636 auto indices = std::make_index_sequence{};
│ │ │ │ │ -637
│ │ │ │ │ -638 // unfold apply_i left to right
│ │ │ │ │ -639 return unpackIntegerSequence([&](auto... i) {
│ │ │ │ │ -659 return left_fold(std::move(apply_i),std::move(pre_val), i...);
│ │ │ │ │ -660 }, indices);
│ │ │ │ │ -661
│ │ │ │ │ -662 } else {
│ │ │ │ │ -663 // unfold first child to get type
│ │ │ │ │ -664 auto i_val = apply_i(std::move(pre_val),std::size_t{0});
│ │ │ │ │ -665 // dynamically loop rest of the children to accumulate remindng values
│ │ │ │ │ -666 for(std::size_t i = 1; i < tree.degree(); i++)
│ │ │ │ │ -667 i_val = apply_i(i_val,i);
│ │ │ │ │ -668 return i_val;
│ │ │ │ │ -669 }
│ │ │ │ │ -670 }();
│ │ │ │ │ -671
│ │ │ │ │ -672 return visitor.post(tree, _t_r_e_e_P_a_t_h, in_val);
│ │ │ │ │ -673 }
│ │ │ │ │ -674
│ │ │ │ │ -675 }
│ │ │ │ │ -676
│ │ │ │ │ -700 template
│ │ │ │ │ -_7_0_1 auto hybridApplyToTree(Tree&& tree, Visitor&& visitor, Init&& init)
│ │ │ │ │ -702 {
│ │ │ │ │ -703 return Impl::hybridApplyToTree(tree, _h_y_b_r_i_d_T_r_e_e_P_a_t_h(), visitor, init);
│ │ │ │ │ -704 }
│ │ │ │ │ -705
│ │ │ │ │ -706 } // namespace Experimental
│ │ │ │ │ -707
│ │ │ │ │ -709 } // namespace TypeTree
│ │ │ │ │ -710} //namespace Dune
│ │ │ │ │ -711
│ │ │ │ │ -712#endif // DUNE_TYPETREE_ACCUMULATE_STATIC_HH
│ │ │ │ │ -_c_h_i_l_d___r_e_s_u_l_t
│ │ │ │ │ -static const result_type child_result
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:156
│ │ │ │ │ +91
│ │ │ │ │ +92 } // namespace TypeTree
│ │ │ │ │ +93} //namespace Dune
│ │ │ │ │ +94
│ │ │ │ │ +95#endif // DUNE_TYPETREE_TRAVERSALUTILITIES_HH
│ │ │ │ │ +___r_e_d_u_c_t_i_o_n
│ │ │ │ │ +R _reduction
│ │ │ │ │ +DDeeffiinniittiioonn traversalutilities.hh:49
│ │ │ │ │ +___f_u_n_c_t_o_r
│ │ │ │ │ +F _functor
│ │ │ │ │ +DDeeffiinniittiioonn traversalutilities.hh:48
│ │ │ │ │ +_t_r_e_e_P_a_t_h_T_y_p_e
│ │ │ │ │ +static const TreePathType::Type treePathType
│ │ │ │ │ +DDeeffiinniittiioonn traversalutilities.hh:32
│ │ │ │ │ +___v_a_l_u_e
│ │ │ │ │ +ResultType _value
│ │ │ │ │ +DDeeffiinniittiioonn traversalutilities.hh:50
│ │ │ │ │ _r_e_s_u_l_t
│ │ │ │ │ static const result_type result
│ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:113
│ │ │ │ │ -_u_t_i_l_i_t_y_._h_h
│ │ │ │ │ -_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h
│ │ │ │ │ -_n_o_d_e_t_a_g_s_._h_h
│ │ │ │ │ -_t_r_e_e_p_a_t_h_._h_h
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_h_i_l_d
│ │ │ │ │ -typename impl::_Child< Node, indices... >::type Child
│ │ │ │ │ -Template alias for the type of a child node given by a list of child indices.
│ │ │ │ │ -DDeeffiinniittiioonn childextraction.hh:225
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_c_h_i_l_d
│ │ │ │ │ -ImplementationDefined child(Node &&node, Indices... indices)
│ │ │ │ │ -Extracts the child of a node given by a sequence of compile-time and run-time
│ │ │ │ │ -indices.
│ │ │ │ │ -DDeeffiinniittiioonn childextraction.hh:128
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_N_o_d_e_T_a_g
│ │ │ │ │ -typename std::decay_t< Node >::NodeTag NodeTag
│ │ │ │ │ -Returns the node tag of the given Node.
│ │ │ │ │ -DDeeffiinniittiioonn nodeinterface.hh:70
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_u_s_h___b_a_c_k
│ │ │ │ │ -constexpr HybridTreePath< T..., std::size_t > push_back(const HybridTreePath<
│ │ │ │ │ -T... > &tp, std::size_t i)
│ │ │ │ │ -Appends a run time index to a HybridTreePath.
│ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:416
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_y_b_r_i_d_T_r_e_e_P_a_t_h
│ │ │ │ │ -constexpr auto hybridTreePath(const T &... t)
│ │ │ │ │ -Constructs a new HybridTreePath from the given indices.
│ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:312
│ │ │ │ │ +_t_r_a_v_e_r_s_a_l_._h_h
│ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_r_e_d_u_c_e_O_v_e_r_L_e_a_f_s
│ │ │ │ │ +ResultType reduceOverLeafs(const Tree &tree, F functor, R reduction, ResultType
│ │ │ │ │ +startValue)
│ │ │ │ │ +Calculate a quantity as a reduction over the leaf nodes of a TypeTree.
│ │ │ │ │ +DDeeffiinniittiioonn traversalutilities.hh:83
│ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_p_p_l_y_T_o_T_r_e_e
│ │ │ │ │ +void applyToTree(Tree &&tree, Visitor &&visitor)
│ │ │ │ │ +Apply visitor to TypeTree.
│ │ │ │ │ +DDeeffiinniittiioonn traversal.hh:239
│ │ │ │ │ _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_t_r_e_e_P_a_t_h
│ │ │ │ │ constexpr auto treePath(const T &... t)
│ │ │ │ │ Constructs a new HybridTreePath from the given indices.
│ │ │ │ │ DDeeffiinniittiioonn treepath.hh:326
│ │ │ │ │ _D_u_n_e
│ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_r__
│ │ │ │ │ -Statically combine two values of type result_type using ||.
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:27
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_r___:_:_r_e_d_u_c_e
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:30
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_r___:_:_r_e_d_u_c_e_:_:_r_e_s_u_l_t
│ │ │ │ │ -static const result_type result
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:31
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_n_d__
│ │ │ │ │ -Statically combine two values of type result_type using &&.
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:38
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_n_d___:_:_r_e_d_u_c_e
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:41
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_n_d___:_:_r_e_d_u_c_e_:_:_r_e_s_u_l_t
│ │ │ │ │ -static const result_type result
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:42
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_l_u_s
│ │ │ │ │ -Statically combine two values of type result_type using +.
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:49
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_l_u_s_:_:_r_e_d_u_c_e
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:52
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_l_u_s_:_:_r_e_d_u_c_e_:_:_r_e_s_u_l_t
│ │ │ │ │ -static const result_type result
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:53
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_i_n_u_s
│ │ │ │ │ -Statically combine two values of type result_type using -.
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:60
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_i_n_u_s_:_:_r_e_d_u_c_e
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:63
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_i_n_u_s_:_:_r_e_d_u_c_e_:_:_r_e_s_u_l_t
│ │ │ │ │ -static const result_type result
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:64
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_u_l_t_i_p_l_y
│ │ │ │ │ -Statically combine two values of type result_type using *.
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:71
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_u_l_t_i_p_l_y_:_:_r_e_d_u_c_e
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:74
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_u_l_t_i_p_l_y_:_:_r_e_d_u_c_e_:_:_r_e_s_u_l_t
│ │ │ │ │ -static const result_type result
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:75
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_i_n
│ │ │ │ │ -Statically combine two values of type result_type by returning their minimum.
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:82
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_i_n_:_:_r_e_d_u_c_e
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:85
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_i_n_:_:_r_e_d_u_c_e_:_:_r_e_s_u_l_t
│ │ │ │ │ -static const result_type result
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:86
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_a_x
│ │ │ │ │ -Statically combine two values of type result_type by returning their maximum.
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:93
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_a_x_:_:_r_e_d_u_c_e
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:96
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_a_x_:_:_r_e_d_u_c_e_:_:_r_e_s_u_l_t
│ │ │ │ │ -static const result_type result
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:97
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_c_c_u_m_u_l_a_t_e_V_a_l_u_e
│ │ │ │ │ -Statically accumulate a value over the nodes of a TypeTree.
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:262
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_c_c_u_m_u_l_a_t_e_V_a_l_u_e_:_:_r_e_s_u_l_t___t_y_p_e
│ │ │ │ │ -Functor::result_type result_type
│ │ │ │ │ -The result type of the computation.
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:265
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_c_c_u_m_u_l_a_t_e_V_a_l_u_e_:_:_r_e_s_u_l_t
│ │ │ │ │ -static const result_type result
│ │ │ │ │ -The accumulated result of the computation.
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:268
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_y_p_e_A_c_c_u_m_u_l_a_t_i_o_n_P_o_l_i_c_y
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:469
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_y_p_e_A_c_c_u_m_u_l_a_t_i_o_n_P_o_l_i_c_y_:_:_p_a_r_e_n_t___c_h_i_l_d___r_e_d_u_c_t_i_o_n
│ │ │ │ │ -ParentChildReduction parent_child_reduction
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:527
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_y_p_e_A_c_c_u_m_u_l_a_t_i_o_n_P_o_l_i_c_y_:_:_f_u_n_c_t_o_r
│ │ │ │ │ -Functor functor
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:498
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_y_p_e_A_c_c_u_m_u_l_a_t_i_o_n_P_o_l_i_c_y_:_:_s_t_a_r_t___t_y_p_e
│ │ │ │ │ -StartType start_type
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:535
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_y_p_e_A_c_c_u_m_u_l_a_t_i_o_n_P_o_l_i_c_y_:_:_r_e_d_u_c_t_i_o_n___s_t_r_a_t_e_g_y
│ │ │ │ │ -ReductionAlgorithm reduction_strategy
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:541
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_y_p_e_A_c_c_u_m_u_l_a_t_i_o_n_P_o_l_i_c_y_:_:_s_i_b_l_i_n_g___r_e_d_u_c_t_i_o_n
│ │ │ │ │ -Reduction sibling_reduction
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:519
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_c_c_u_m_u_l_a_t_e_T_y_p_e
│ │ │ │ │ -Statically accumulate a type over the nodes of a TypeTree.
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:556
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_c_c_u_m_u_l_a_t_e_T_y_p_e_:_:_t_y_p_e
│ │ │ │ │ -accumulate_type< Tree, Policy, typenamePolicy::start_type, HybridTreePath<>,
│ │ │ │ │ -NodeTag< Tree > >::type type
│ │ │ │ │ -The accumulated result of the computation.
│ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:565
│ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_H_y_b_r_i_d_T_r_e_e_P_a_t_h
│ │ │ │ │ -A hybrid version of TreePath that supports both compile time and run time
│ │ │ │ │ -indices.
│ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:158
│ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_T_y_p_e_:_:_T_y_p_e
│ │ │ │ │ +Type
│ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:106
│ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_T_y_p_e_:_:_d_y_n_a_m_i_c
│ │ │ │ │ +@ dynamic
│ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:106
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00011.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-typetree: filteredcompositenode.hh File Reference
│ │ │ │ +dune-typetree: exceptions.hh File Reference
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -72,44 +72,39 @@
│ │ │ │ dune typetree
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ 3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 107 template<typename Node, typename Functor, typename Reduction, typename Functor::result_type current_value, typename TreePath, bool doVisit>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 118 template<typename Node, typename Functor, typename Reduction, typename Functor::result_type current_value, typename TreePath>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 124 static const result_type result = Reduction::template reduce<current_value,Functor::template visit<Node,TreePath>::result>::result;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 129 template<typename Tree, typename Functor, typename Reduction, typename ParentChildReduction, typename Functor::result_type current_value, typename TreePath, typename Tag>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 133 template<typename LeafNode, typename Functor, typename Reduction, typename ParentChildReduction, typename Functor::result_type current_value, typename TreePath>
│ │ │ │ - 134 struct accumulate_value<LeafNode,Functor,Reduction,ParentChildReduction,current_value,TreePath,LeafNodeTag>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 141 accumulate_node_helper<LeafNode,Functor,Reduction,current_value,TreePath,Functor::template doVisit<LeafNode,TreePath>::value>::result;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 146 template<typename Node, typename Functor, typename Reduction, typename ParentChildReduction, typename Functor::result_type current_value, typename TreePath, std::size_t i, std::size_t n>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 156 static const result_type child_result = accumulate_value<child,Functor,Reduction,ParentChildReduction,current_value,child_tree_path,NodeTag<child>>::result;
│ │ │ │ -
│ │ │ │ - 158 static const result_type result = accumulate_over_children<Node,Functor,Reduction,ParentChildReduction,child_result,TreePath,i+1,n>::result;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 163 template<typename Node, typename Functor, typename Reduction, typename ParentChildReduction, typename Functor::result_type current_value, typename TreePath, std::size_t n>
│ │ │ │ - 164 struct accumulate_over_children<Node,Functor,Reduction,ParentChildReduction,current_value,TreePath,n,n>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 175 template<typename Node, typename Functor, typename Reduction, typename ParentChildReduction, typename Functor::result_type current_value, typename TreePath>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 181 static const result_type child_result = accumulate_over_children<Node,Functor,Reduction,ParentChildReduction,current_value,TreePath,0,StaticDegree<Node>::value>::result;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 184 accumulate_node_helper<Node,Functor,ParentChildReduction,child_result,TreePath,Functor::template doVisit<Node,TreePath>::value>::result;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 190 template<typename PowerNode, typename Functor, typename Reduction, typename ParentChildReduction, typename Functor::result_type current_value, typename TreePath>
│ │ │ │ - 191 struct accumulate_value<PowerNode,Functor,Reduction,ParentChildReduction,current_value,TreePath,PowerNodeTag>
│ │ │ │ - 192 : public accumulate_value_generic_composite_node<PowerNode,Functor,Reduction,ParentChildReduction,current_value,TreePath>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 196 template<typename CompositeNode, typename Functor, typename Reduction, typename ParentChildReduction, typename Functor::result_type current_value, typename TreePath>
│ │ │ │ - 197 struct accumulate_value<CompositeNode,Functor,Reduction,ParentChildReduction,current_value,TreePath,CompositeNodeTag>
│ │ │ │ - 198 : public accumulate_value_generic_composite_node<CompositeNode,Functor,Reduction,ParentChildReduction,current_value,TreePath>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 260 template<typename Tree, typename Functor, typename Reduction, typename Functor::result_type startValue, typename ParentChildReduction = Reduction>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 268 static const result_type result = accumulate_value<Tree,Functor,Reduction,ParentChildReduction,startValue,HybridTreePath<>,NodeTag<Tree>>::result;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 286 template<typename Node, typename Functor, typename Reduction, typename current_type, typename TreePath, bool doVisit>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 295 template<typename Node, typename Functor, typename Reduction, typename current_type, typename TreePath>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 310 template<typename Tree, typename Policy, typename current_type, typename TreePath, typename Tag>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 334 template<typename current_type, typename tree_path, typename start_type, typename reduction_strategy>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 367 template<typename Node, typename Policy, typename current_type, typename TreePath, std::size_t i, std::size_t n>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 401 template<typename Node, typename Policy, typename current_type, typename TreePath, std::size_t n>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 603 using preferDynamicTraversal = std::bool_constant<Visitor::treePathType == TreePathType::dynamic>;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -typename impl::_Child< Node, indices... >::type Child
Template alias for the type of a child node given by a list of child indices.
Definition childextraction.hh:225
ImplementationDefined child(Node &&node, Indices... indices)
Extracts the child of a node given by a sequence of compile-time and run-time indices.
Definition childextraction.hh:128
typename std::decay_t< Node >::NodeTag NodeTag
Returns the node tag of the given Node.
Definition nodeinterface.hh:70
constexpr HybridTreePath< T..., std::size_t > push_back(const HybridTreePath< T... > &tp, std::size_t i)
Appends a run time index to a HybridTreePath.
Definition treepath.hh:416
constexpr auto hybridTreePath(const T &... t)
Constructs a new HybridTreePath from the given indices.
Definition treepath.hh:312
ResultType reduceOverLeafs(const Tree &tree, F functor, R reduction, ResultType startValue)
Calculate a quantity as a reduction over the leaf nodes of a TypeTree.
Definition traversalutilities.hh:83
void applyToTree(Tree &&tree, Visitor &&visitor)
Apply visitor to TypeTree.
Definition traversal.hh:239
constexpr auto treePath(const T &... t)
Constructs a new HybridTreePath from the given indices.
Definition treepath.hh:326
Definition accumulate_static.hh:16
Statically combine two values of type result_type using ||.
Definition accumulate_static.hh:27
Definition accumulate_static.hh:30
static const result_type result
Definition accumulate_static.hh:31
Statically combine two values of type result_type using &&.
Definition accumulate_static.hh:38
Definition accumulate_static.hh:41
static const result_type result
Definition accumulate_static.hh:42
Statically combine two values of type result_type using +.
Definition accumulate_static.hh:49
Definition accumulate_static.hh:52
static const result_type result
Definition accumulate_static.hh:53
Statically combine two values of type result_type using -.
Definition accumulate_static.hh:60
Definition accumulate_static.hh:63
static const result_type result
Definition accumulate_static.hh:64
Statically combine two values of type result_type using *.
Definition accumulate_static.hh:71
Definition accumulate_static.hh:74
static const result_type result
Definition accumulate_static.hh:75
Statically combine two values of type result_type by returning their minimum.
Definition accumulate_static.hh:82
Definition accumulate_static.hh:85
static const result_type result
Definition accumulate_static.hh:86
Statically combine two values of type result_type by returning their maximum.
Definition accumulate_static.hh:93
Definition accumulate_static.hh:96
static const result_type result
Definition accumulate_static.hh:97
Statically accumulate a value over the nodes of a TypeTree.
Definition accumulate_static.hh:262
Functor::result_type result_type
The result type of the computation.
Definition accumulate_static.hh:265
static const result_type result
The accumulated result of the computation.
Definition accumulate_static.hh:268
Definition accumulate_static.hh:469
ParentChildReduction parent_child_reduction
Definition accumulate_static.hh:527
StartType start_type
Definition accumulate_static.hh:535
ReductionAlgorithm reduction_strategy
Definition accumulate_static.hh:541
Reduction sibling_reduction
Definition accumulate_static.hh:519
Statically accumulate a type over the nodes of a TypeTree.
Definition accumulate_static.hh:556
accumulate_type< Tree, Policy, typenamePolicy::start_type, HybridTreePath<>, NodeTag< Tree > >::type type
The accumulated result of the computation.
Definition accumulate_static.hh:565
A hybrid version of TreePath that supports both compile time and run time indices.
Definition treepath.hh:158
│ │ │ │ Generated by
1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,698 +1,109 @@
│ │ │ │ │ dune-typetree 2.10
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _t_y_p_e_t_r_e_e
│ │ │ │ │ -accumulate_static.hh
│ │ │ │ │ +traversalutilities.hh
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ 2// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ 3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 4// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-with-
│ │ │ │ │ PDELab-exception
│ │ │ │ │ 5
│ │ │ │ │ -6#ifndef DUNE_TYPETREE_ACCUMULATE_STATIC_HH
│ │ │ │ │ -7#define DUNE_TYPETREE_ACCUMULATE_STATIC_HH
│ │ │ │ │ +6#ifndef DUNE_TYPETREE_TRAVERSALUTILITIES_HH
│ │ │ │ │ +7#define DUNE_TYPETREE_TRAVERSALUTILITIES_HH
│ │ │ │ │ 8
│ │ │ │ │ -9#include
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ Classes |
│ │ │ │ Namespaces
│ │ │ │ - filteredcompositenode.hh File Reference
exceptions.hh File Reference
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ + │ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ #include <memory>│ │ │ │ -
#include <tuple>│ │ │ │ -
#include <type_traits>│ │ │ │ -
#include <dune/typetree/nodetags.hh>│ │ │ │ -
#include <dune/typetree/filters.hh>│ │ │ │ -
#include <dune/common/shared_ptr.hh>│ │ │ │ -
#include <dune/common/typetraits.hh>│ │ │ │ -
#include <dune/common/indices.hh>│ │ │ │ + │ │ │ │ +
TypeTree-specific exceptions. │ │ │ │ +More...
│ │ │ │ +#include <dune/common/exceptions.hh>│ │ │ │
Go to the source code of this file.
│ │ │ ││ │ │ │ Classes | |
| class | Dune::TypeTree::FilteredCompositeNode< Node, Filter > |
| Base class for composite nodes representing a filtered view on an underlying composite node. More... | |
| struct | Dune::TypeTree::FilteredCompositeNode< Node, Filter >::Child< k > |
| Access to the type and storage type of the i-th child. More... | |
| class | Dune::TypeTree::Exception |
| Base class for all TypeTree exceptions. More... | |
│ │ │ │ Namespaces | |
| namespace | Dune |
| namespace | Dune::TypeTree |
Detailed Description
│ │ │ │ +TypeTree-specific exceptions.
│ │ │ │ +│ │ │ │ Generated by
1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,32 +1,24 @@
│ │ │ │ │ dune-typetree 2.10
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _t_y_p_e_t_r_e_e
│ │ │ │ │ _C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ -filteredcompositenode.hh File Reference
│ │ │ │ │ -#include
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ filteredcompositenode.hh
exceptions.hh
│ │ │ │ Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │
3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ 89 static const bool nodeIsConst = std::is_const<typename std::remove_reference<Node>::type>::value;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -Definition accumulate_static.hh:16
Base class for composite nodes representing a filtered view on an underlying composite node.
Definition filteredcompositenode.hh:83
auto childStorage(index_constant< k >={}) const
Returns the storage of the k-th child (const version).
Definition filteredcompositenode.hh:181
static constexpr auto degree()
Definition filteredcompositenode.hh:117
mapped_children::NodeStorage NodeStorage
The type used for storing the children.
Definition filteredcompositenode.hh:103
void setChild(ChildType &&child, typename std::enable_if< lazy_enable< k >::value, void * >::type=0)
Sets the k-th child to the passed-in value.
Definition filteredcompositenode.hh:188
static const bool isLeaf
Mark this class as non leaf in the dune-typetree.
Definition filteredcompositenode.hh:109
const Node & unfiltered() const
Returns the unfiltered node (const version).
Definition filteredcompositenode.hh:215
static const bool isComposite
Mark this class as a composite in the dune-typetree.
Definition filteredcompositenode.hh:115
std::enable_if< enabled, std::shared_ptr< Node > >::type unfilteredStorage()
Returns the storage object of the unfiltered node.
Definition filteredcompositenode.hh:226
static const bool isPower
Mark this class as a non power in the dune-typetree.
Definition filteredcompositenode.hh:112
FilteredCompositeNode(Node &node)
Initialize the CompositeNode with a copy of the passed-in storage type.
Definition filteredcompositenode.hh:253
FilteredCompositeNode(std::shared_ptr< Node > node)
Initialize the CompositeNode with copies of the passed in Storage objects.
Definition filteredcompositenode.hh:248
auto childStorage(index_constant< k >={})
Returns the storage of the k-th child.
Definition filteredcompositenode.hh:171
const auto & child(index_constant< k >={}) const
Returns the k-th child (const version).
Definition filteredcompositenode.hh:160
auto & child(index_constant< k >={})
Returns the k-th child.
Definition filteredcompositenode.hh:150
CompositeNodeTag NodeTag
The type tag that describes a CompositeNode.
Definition filteredcompositenode.hh:100
mapped_children::ChildTypes ChildTypes
A tuple storing the types of all children.
Definition filteredcompositenode.hh:106
std::enable_if< enabled, Node & >::type unfiltered()
Returns the unfiltered node.
Definition filteredcompositenode.hh:206
std::shared_ptr< const Node > unfilteredStorage() const
Returns the storage object of the unfiltered node (const version).
Definition filteredcompositenode.hh:235
Access to the type and storage type of the i-th child.
Definition filteredcompositenode.hh:124
OriginalChild::type type
The type of the child.
Definition filteredcompositenode.hh:138
OriginalChild::Type Type
The type of the child.
Definition filteredcompositenode.hh:135
│ │ │ │ Generated by
1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,333 +1,37 @@
│ │ │ │ │ dune-typetree 2.10
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _t_y_p_e_t_r_e_e
│ │ │ │ │ -filteredcompositenode.hh
│ │ │ │ │ +exceptions.hh
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ 2// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ 3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 4// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-with-
│ │ │ │ │ PDELab-exception
│ │ │ │ │ -5
│ │ │ │ │ -6#ifndef DUNE_TYPETREE_FILTEREDCOMPOSITENODE_HH
│ │ │ │ │ -7#define DUNE_TYPETREE_FILTEREDCOMPOSITENODE_HH
│ │ │ │ │ -8
│ │ │ │ │ -9#include -
│ │ │ │