--- /srv/reproducible-results/rbuild-debian/r-b-build.5Cq3nWCs/b1/dune-typetree_2.10.0-1_i386.changes +++ /srv/reproducible-results/rbuild-debian/r-b-build.5Cq3nWCs/b2/dune-typetree_2.10.0-1_i386.changes ├── Files │ @@ -1,3 +1,3 @@ │ │ 280a4948b81ad2bca2da45652b369439 41680 libdevel optional libdune-typetree-dev_2.10.0-1_i386.deb │ - ad002fc80a7b8107846da20bd79b5eec 991664 doc optional libdune-typetree-doc_2.10.0-1_all.deb │ + 80c68df987f262a8cf531537681fb421 991388 doc optional libdune-typetree-doc_2.10.0-1_all.deb ├── libdune-typetree-doc_2.10.0-1_all.deb │ ├── file list │ │ @@ -1,3 +1,3 @@ │ │ -rw-r--r-- 0 0 0 4 2024-11-14 20:30:42.000000 debian-binary │ │ --rw-r--r-- 0 0 0 9644 2024-11-14 20:30:42.000000 control.tar.xz │ │ --rw-r--r-- 0 0 0 981828 2024-11-14 20:30:42.000000 data.tar.xz │ │ +-rw-r--r-- 0 0 0 9648 2024-11-14 20:30:42.000000 control.tar.xz │ │ +-rw-r--r-- 0 0 0 981548 2024-11-14 20:30:42.000000 data.tar.xz │ ├── control.tar.xz │ │ ├── control.tar │ │ │ ├── ./md5sums │ │ │ │ ├── ./md5sums │ │ │ │ │┄ Files differ │ ├── data.tar.xz │ │ ├── data.tar │ │ │ ├── file list │ │ │ │ @@ -5,68 +5,68 @@ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 885 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/changelog.Debian.gz │ │ │ │ -rw-r--r-- 0 root (0) root (0) 2679 2024-09-05 06:40:04.000000 ./usr/share/doc/libdune-typetree-doc/changelog.gz │ │ │ │ -rw-r--r-- 0 root (0) root (0) 3031 2023-01-12 15:07:35.000000 ./usr/share/doc/libdune-typetree-doc/copyright │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 3048 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00002.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 3046 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00005.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 9728 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00008.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 67498 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00008_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 17215 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00011.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 73690 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00011_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 11111 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00014.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 56098 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00014_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 6911 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00017.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 15988 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00017_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 6860 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00020.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 87521 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00020_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 5150 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00023.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 32708 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00023_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 5910 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00026.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 48639 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00026_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 8712 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00029.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 19409 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00029_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 15110 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00032.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 97993 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00032_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 7399 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00035.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 41519 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00035_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 6195 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00038.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 68730 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00038_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 37497 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00041.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 127500 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00041_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 15418 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00044.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 53520 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00044_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 5534 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00047.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 38082 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00047_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 3695 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00050.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 5943 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00050_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 10552 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00053.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 47000 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00053_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 6234 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00056.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 9310 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00056_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 4850 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00059.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 9300 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00059_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 8737 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00062.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 57453 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00062_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 7065 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00065.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 26864 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00065_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 5126 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00068.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 13808 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00068_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 6050 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00071.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 48822 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00071_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 11231 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00074.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 43487 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00074_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 5604 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00077.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 39473 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00077_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 13745 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00080.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 52788 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00080_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 7479 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00083.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 17526 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00083_source.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 5212 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00086.html │ │ │ │ --rw-r--r-- 0 root (0) root (0) 7085 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00086_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 10552 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00008.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 47000 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00008_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 6195 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00011.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 68730 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00011_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 15418 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00014.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 53520 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00014_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 11111 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00017.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 56098 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00017_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 3695 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00020.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 5943 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00020_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 15110 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00023.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 97993 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00023_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 5604 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00026.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 39473 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00026_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 5150 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00029.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 32708 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00029_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 4850 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00032.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 9300 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00032_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 5534 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00035.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 38082 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00035_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 7065 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00038.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 26864 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00038_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 5212 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00041.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 7085 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00041_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 5910 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00044.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 48639 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00044_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 11231 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00047.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 43487 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00047_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 6234 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00050.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 9310 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00050_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 8712 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00053.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 19409 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00053_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 7479 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00056.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 17526 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00056_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 13745 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00059.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 52788 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00059_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 37497 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00062.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 127500 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00062_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 7399 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00065.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 41519 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00065_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 8737 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00068.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 57453 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00068_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 5126 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00071.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 13808 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00071_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 17215 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00074.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 73690 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00074_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 6860 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00077.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 87521 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00077_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 9728 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00080.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 67498 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00080_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 6050 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00083.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 48822 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00083_source.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 6911 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00086.html │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 15988 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00086_source.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 16500 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00089.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 11643 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00089.png │ │ │ │ -rw-r--r-- 0 root (0) root (0) 33697 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00090.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 4364 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00090.png │ │ │ │ -rw-r--r-- 0 root (0) root (0) 21122 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00091.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 3530 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00091.png │ │ │ │ -rw-r--r-- 0 root (0) root (0) 25232 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/a00092.html │ │ │ │ @@ -372,15 +372,15 @@ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 3903 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/dir_04f2ecc425faf0d475a3caf484e551f3.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 2277 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/dir_04f2ecc425faf0d475a3caf484e551f3_dep.png │ │ │ │ -rw-r--r-- 0 root (0) root (0) 3676 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/dir_5e69be5995c9f5d42bf491ae6f29600e.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 13067 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/dir_5e74c06688912037f4b476b8dc05fab9.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 2105 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/dir_5e74c06688912037f4b476b8dc05fab9_dep.png │ │ │ │ -rw-r--r-- 0 root (0) root (0) 3672 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/dir_e68e8157741866f444e17edd764ebbae.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 45631 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/doxygen.css │ │ │ │ --rw-r--r-- 0 root (0) root (0) 23506 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/dune-typetree.tag.gz │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 23508 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/dune-typetree.tag.gz │ │ │ │ -rw-r--r-- 0 root (0) root (0) 7704 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/dynsections.js │ │ │ │ -rw-r--r-- 0 root (0) root (0) 12259 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/files.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 3441 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/functions.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 3960 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/functions_b.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 6674 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/functions_c.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 6085 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/functions_d.html │ │ │ │ -rw-r--r-- 0 root (0) root (0) 3515 2024-11-14 20:30:42.000000 ./usr/share/doc/libdune-typetree-doc/doxygen/functions_e.html │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00008.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: proxynode.hh File Reference │ │ │ │ +dune-typetree: childextraction.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -70,61 +70,66 @@ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ │
│ │ │ │ -Classes | │ │ │ │ -Namespaces
│ │ │ │ -
proxynode.hh File Reference
│ │ │ │ +Namespaces | │ │ │ │ +Typedefs | │ │ │ │ +Functions
│ │ │ │ +
childextraction.hh File Reference
│ │ │ │ │ │ │ │
│ │ │ │
#include <type_traits>
│ │ │ │ -#include <dune/typetree/nodeinterface.hh>
│ │ │ │ -#include <dune/typetree/nodetags.hh>
│ │ │ │ +#include <utility>
│ │ │ │ +#include <dune/common/concept.hh>
│ │ │ │ +#include <dune/common/documentation.hh>
│ │ │ │ +#include <dune/common/typetraits.hh>
│ │ │ │ #include <dune/common/shared_ptr.hh>
│ │ │ │ -#include <dune/common/indices.hh>
│ │ │ │ -#include <dune/common/std/type_traits.hh>
│ │ │ │ +#include <dune/typetree/nodeinterface.hh>
│ │ │ │ +#include <dune/typetree/treepath.hh>
│ │ │ │
│ │ │ │

Go to the source code of this file.

│ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -

│ │ │ │ -Classes

class  Dune::TypeTree::StaticChildAccessors< ProxiedNode >
 Mixin class providing methods for child access with compile-time parameter. More...
 
struct  Dune::TypeTree::StaticChildAccessors< ProxiedNode >::Child< k >
 Access to the type and storage type of the i-th child. More...
 
class  Dune::TypeTree::DynamicChildAccessors< ProxiedNode >
 Mixin class providing methods for child access with run-time parameter. More...
 
struct  Dune::TypeTree::ProxyNodeBase< Node, LeafNodeTag >
 ProxyNode base class for LeafNode. More...
 
struct  Dune::TypeTree::ProxyNodeBase< Node, CompositeNodeTag >
 ProxyNode base class for CompositeNode. More...
 
struct  Dune::TypeTree::ProxyNodeBase< Node, PowerNodeTag >
 ProxyNode base class for PowerNode. More...
 
struct  Dune::TypeTree::ProxyNodeBase< Node, DynamicPowerNodeTag >
 ProxyNode base class for DynamicPowerNode. More...
 
class  Dune::TypeTree::ProxyNode< Node >
 Base class for nodes acting as a proxy for an existing node. More...
 
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ +

│ │ │ │ Namespaces

namespace  Dune
 
namespace  Dune::TypeTree
 
│ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +

│ │ │ │ +Typedefs

template<typename Node , std::size_t... indices>
using Dune::TypeTree::Child = typename impl::_Child< Node, indices... >::type
 Template alias for the type of a child node given by a list of child indices.
 
template<typename Node , typename TreePath >
using Dune::TypeTree::ChildForTreePath = typename impl::_ChildForTreePath< Node, TreePath >::type
 Template alias for the type of a child node given by a TreePath or a HybridTreePath type.
 
template<typename T >
using Dune::TypeTree::is_flat_index = typename impl::_is_flat_index< std::decay_t< T > >::type
 Type trait that determines whether T is a flat index in the context of child extraction.
 
│ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │

│ │ │ │ +Functions

template<typename Node , typename... Indices>
ImplementationDefined Dune::TypeTree::child (Node &&node, Indices... indices)
 Extracts the child of a node given by a sequence of compile-time and run-time indices.
 
template<typename Node , typename... Indices>
ImplementationDefined Dune::TypeTree::childStorage (Node &&node, Indices... indices)
 
template<typename Node , typename... Indices>
ImplementationDefined Dune::TypeTree::child (Node &&node, HybridTreePath< Indices... > treePath)
 Extracts the child of a node given by a HybridTreePath object.
 
│ │ │ │
│ │ │ │ │ │ │ │
│ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
│ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,49 +1,58 @@ │ │ │ │ │ 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 │ │ │ │ │ -proxynode.hh File Reference │ │ │ │ │ +_N_a_m_e_s_p_a_c_e_s | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s │ │ │ │ │ +childextraction.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 │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ #include │ │ │ │ │ -#include │ │ │ │ │ -#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_/_t_r_e_e_p_a_t_h_._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 │ │ │ │ │ - class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_<_ _P_r_o_x_i_e_d_N_o_d_e_ _> │ │ │ │ │ -  Mixin class providing methods for child access with compile-time │ │ │ │ │ - parameter. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_<_ _P_r_o_x_i_e_d_N_o_d_e_ _>_:_:_C_h_i_l_d_<_ _k_ _> │ │ │ │ │ -  Access to the type and storage type of the i-th child. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ - class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_<_ _P_r_o_x_i_e_d_N_o_d_e_ _> │ │ │ │ │ -  Mixin class providing methods for child access with run-time │ │ │ │ │ - parameter. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _L_e_a_f_N_o_d_e_T_a_g_ _> │ │ │ │ │ -  _P_r_o_x_y_N_o_d_e base class for _L_e_a_f_N_o_d_e. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g_ _> │ │ │ │ │ -  _P_r_o_x_y_N_o_d_e base class for _C_o_m_p_o_s_i_t_e_N_o_d_e. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _P_o_w_e_r_N_o_d_e_T_a_g_ _> │ │ │ │ │ -  _P_r_o_x_y_N_o_d_e base class for _P_o_w_e_r_N_o_d_e. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g_ _> │ │ │ │ │ -  _P_r_o_x_y_N_o_d_e base class for _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ - class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_<_ _N_o_d_e_ _> │ │ │ │ │ -  Base class for nodes acting as a proxy for an existing node. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ NNaammeessppaacceess │ │ │ │ │ namespace   _D_u_n_e │ │ │ │ │   │ │ │ │ │ namespace   _D_u_n_e_:_:_T_y_p_e_T_r_e_e │ │ │ │ │   │ │ │ │ │ +TTyyppeeddeeffss │ │ │ │ │ +template │ │ │ │ │ +using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_h_i_l_d = typename impl::_Child< Node, indices... >::type │ │ │ │ │ +  Template alias for the type of a child node given by a list of child │ │ │ │ │ + indices. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ +using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_h_i_l_d_F_o_r_T_r_e_e_P_a_t_h = typename impl::_ChildForTreePath< │ │ │ │ │ + Node, TreePath >::type │ │ │ │ │ +  Template alias for the type of a child node given by a TreePath or a │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h type. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ +using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_s___f_l_a_t___i_n_d_e_x = typename impl::_is_flat_index< std:: │ │ │ │ │ + decay_t< T > >::type │ │ │ │ │ +  Type trait that determines whether T is a flat index in the context of │ │ │ │ │ + child extraction. │ │ │ │ │ +  │ │ │ │ │ +FFuunnccttiioonnss │ │ │ │ │ +template │ │ │ │ │ +ImplementationDefined  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_c_h_i_l_d (Node &&node, Indices... indices) │ │ │ │ │ +  Extracts the child of a node given by a sequence of │ │ │ │ │ + compile-time and run-time indices. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ +ImplementationDefined  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e (Node &&node, Indices... │ │ │ │ │ + indices) │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ +ImplementationDefined  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_c_h_i_l_d (Node &&node, _H_y_b_r_i_d_T_r_e_e_P_a_t_h< │ │ │ │ │ + Indices... > _t_r_e_e_P_a_t_h) │ │ │ │ │ +  Extracts the child of a node given by a _H_y_b_r_i_d_T_r_e_e_P_a_t_h │ │ │ │ │ + object. │ │ │ │ │ +  │ │ │ │ │ =============================================================================== │ │ │ │ │ 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: proxynode.hh Source File │ │ │ │ +dune-typetree: childextraction.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,397 +74,290 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ │ -
proxynode.hh
│ │ │ │ +
childextraction.hh
│ │ │ │
│ │ │ │
│ │ │ │ -Go to the documentation of this file.
1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ -
2// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ +Go to the documentation of this file.
1// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ +
2// vi: set et ts=8 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_PROXYNODE_HH
│ │ │ │ -
7#define DUNE_TYPETREE_PROXYNODE_HH
│ │ │ │ +
6#ifndef DUNE_TYPETREE_CHILDEXTRACTION_HH
│ │ │ │ +
7#define DUNE_TYPETREE_CHILDEXTRACTION_HH
│ │ │ │
8
│ │ │ │
9#include <type_traits>
│ │ │ │ -
10#include <dune/typetree/nodeinterface.hh>
│ │ │ │ -
11#include <dune/typetree/nodetags.hh>
│ │ │ │ -
12#include <dune/common/shared_ptr.hh>
│ │ │ │ -
13#include <dune/common/indices.hh>
│ │ │ │ -
14#include <dune/common/std/type_traits.hh>
│ │ │ │ -
15
│ │ │ │ -
16namespace Dune {
│ │ │ │ -
17 namespace TypeTree {
│ │ │ │ -
18
│ │ │ │ -
24 template<typename Node>
│ │ │ │ -
25 class ProxyNode;
│ │ │ │ -
26
│ │ │ │ -
28 template<typename ProxiedNode>
│ │ │ │ -
│ │ │ │ -
29 class StaticChildAccessors
│ │ │ │ -
30 {
│ │ │ │ -
31
│ │ │ │ -
32 static const bool proxiedNodeIsConst = std::is_const<typename std::remove_reference<ProxiedNode>::type>::value;
│ │ │ │ -
33
│ │ │ │ -
34 template<std::size_t k>
│ │ │ │ -
35 struct lazy_enabled
│ │ │ │ +
10#include <utility>
│ │ │ │ +
11
│ │ │ │ +
12#include <dune/common/concept.hh>
│ │ │ │ +
13#include <dune/common/documentation.hh>
│ │ │ │ +
14#include <dune/common/typetraits.hh>
│ │ │ │ +
15#include <dune/common/shared_ptr.hh>
│ │ │ │ +
16
│ │ │ │ +
17#include <dune/typetree/nodeinterface.hh>
│ │ │ │ +
18#include <dune/typetree/treepath.hh>
│ │ │ │ +
19
│ │ │ │ +
20
│ │ │ │ +
21namespace Dune {
│ │ │ │ +
22 namespace TypeTree {
│ │ │ │ +
23
│ │ │ │ +
28
│ │ │ │ +
29#ifndef DOXYGEN
│ │ │ │ +
30
│ │ │ │ +
31 namespace Impl {
│ │ │ │ +
32
│ │ │ │ +
33 // check at run time whether index is a valid child index
│ │ │ │ +
34 template <class Node, class Index>
│ │ │ │ +
35 std::true_type checkChildIndex (Node const& node, Index i)
│ │ │ │
36 {
│ │ │ │ -
37 static const bool value = !proxiedNodeIsConst;
│ │ │ │ -
38 };
│ │ │ │ -
39
│ │ │ │ -
40 typedef ProxyNode<ProxiedNode> Node;
│ │ │ │ -
41
│ │ │ │ -
42 template<bool enabled = !proxiedNodeIsConst>
│ │ │ │ -
43 typename std::enable_if<enabled,Node&>::type
│ │ │ │ -
44 node ()
│ │ │ │ -
45 {
│ │ │ │ -
46 return static_cast<Node&>(*this);
│ │ │ │ +
37 assert(std::size_t(i) < node.degree() && "Child index out of range");
│ │ │ │ +
38 return {};
│ │ │ │ +
39 }
│ │ │ │ +
40
│ │ │ │ +
41 // check at compile time whether index is a valid index
│ │ │ │ +
42 template <class Node, std::size_t i>
│ │ │ │ +
43 std::bool_constant<(i < Node::degree())> checkChildIndex (Node const& node, index_constant<i>)
│ │ │ │ +
44 {
│ │ │ │ +
45 static_assert(i < Node::degree(), "Child index out of range");
│ │ │ │ +
46 return {};
│ │ │ │
47 }
│ │ │ │
48
│ │ │ │ -
49 const Node& node () const
│ │ │ │ -
50 {
│ │ │ │ -
51 return static_cast<const Node&>(*this);
│ │ │ │ -
52 }
│ │ │ │ -
53
│ │ │ │ -
54 public:
│ │ │ │ -
55
│ │ │ │ -
57 template<std::size_t k>
│ │ │ │ -
│ │ │ │ -
58 struct Child
│ │ │ │ -
59 : public ProxiedNode::template Child<k>
│ │ │ │ -
60 {};
│ │ │ │ -
│ │ │ │ -
61
│ │ │ │ -
64
│ │ │ │ -
66
│ │ │ │ -
69 template<std::size_t k,
│ │ │ │ -
70 typename std::enable_if<lazy_enabled<k>::value, int>::type = 0>
│ │ │ │ -
│ │ │ │ -
71 auto& child (index_constant<k> = {})
│ │ │ │ -
72 {
│ │ │ │ -
73 return node().proxiedNode().template child<k>();
│ │ │ │ -
74 }
│ │ │ │ -
│ │ │ │ -
75
│ │ │ │ -
77
│ │ │ │ -
80 template<std::size_t k>
│ │ │ │ -
│ │ │ │ -
81 const auto& child (index_constant<k> = {}) const
│ │ │ │ -
82 {
│ │ │ │ -
83 return node().proxiedNode().template child<k>();
│ │ │ │ -
84 }
│ │ │ │ -
│ │ │ │ -
85
│ │ │ │ -
87
│ │ │ │ -
90 template<std::size_t k,
│ │ │ │ -
91 typename std::enable_if<lazy_enabled<k>::value, int>::type = 0>
│ │ │ │ -
│ │ │ │ -
92 auto childStorage (index_constant<k> = {})
│ │ │ │ -
93 {
│ │ │ │ -
94 return node().proxiedNode().template childStorage<k>();
│ │ │ │ -
95 }
│ │ │ │ -
│ │ │ │ -
96
│ │ │ │ +
49 // finally return the node itself if no further indices are provided. Break condition
│ │ │ │ +
50 // for the recursion over the node childs.
│ │ │ │ +
51 template<class Node>
│ │ │ │ +
52 decltype(auto) childImpl (Node&& node)
│ │ │ │ +
53 {
│ │ │ │ +
54 return std::forward<Node>(node);
│ │ │ │ +
55 }
│ │ │ │ +
56
│ │ │ │ +
57 template<class NodePtr>
│ │ │ │ +
58 auto childStorageImpl (NodePtr&& nodePtr)
│ │ │ │ +
59 {
│ │ │ │ +
60 return std::forward<NodePtr>(nodePtr);
│ │ │ │ +
61 }
│ │ │ │ +
62
│ │ │ │ +
63 // recursively call `node.child(...)` with the given indices
│ │ │ │ +
64 template<class Node, class I0, class... I>
│ │ │ │ +
65 decltype(auto) childImpl (Node&& node, I0 i0, [[maybe_unused]] I... i)
│ │ │ │ +
66 {
│ │ │ │ +
67 auto valid = checkChildIndex(node,i0);
│ │ │ │ +
68 if constexpr (valid)
│ │ │ │ +
69 return childImpl(node.child(i0),i...);
│ │ │ │ +
70 else
│ │ │ │ +
71 return;
│ │ │ │ +
72 }
│ │ │ │ +
73
│ │ │ │ +
74 // recursively call `node.childStorage(...)` with the given indices
│ │ │ │ +
75 template<class NodePtr, class I0, class... I>
│ │ │ │ +
76 decltype(auto) childStorageImpl (NodePtr&& nodePtr, I0 i0, [[maybe_unused]] I... i)
│ │ │ │ +
77 {
│ │ │ │ +
78 auto valid = checkChildIndex(*nodePtr,i0);
│ │ │ │ +
79 if constexpr (valid)
│ │ │ │ +
80 return childStorageImpl(nodePtr->childStorage(i0),i...);
│ │ │ │ +
81 else
│ │ │ │ +
82 return;
│ │ │ │ +
83 }
│ │ │ │ +
84
│ │ │ │ +
85 // forward to the impl methods by extracting the indices from the treepath
│ │ │ │ +
86 template<class Node, class... Indices, std::size_t... i>
│ │ │ │ +
87 decltype(auto) child (Node&& node, [[maybe_unused]] HybridTreePath<Indices...> tp, std::index_sequence<i...>)
│ │ │ │ +
88 {
│ │ │ │ +
89 return childImpl(std::forward<Node>(node),treePathEntry<i>(tp)...);
│ │ │ │ +
90 }
│ │ │ │ +
91
│ │ │ │ +
92 // forward to the impl methods by extracting the indices from the treepath
│ │ │ │ +
93 template<class NodePtr, class... Indices, std::size_t... i>
│ │ │ │ +
94 decltype(auto) childStorage (NodePtr&& nodePtr, [[maybe_unused]] HybridTreePath<Indices...> tp, std::index_sequence<i...>)
│ │ │ │ +
95 {
│ │ │ │ +
96 return childStorageImpl(std::forward<NodePtr>(nodePtr),treePathEntry<i>(tp)...);
│ │ │ │ +
97 }
│ │ │ │
98
│ │ │ │ -
104 template<std::size_t k>
│ │ │ │ -
│ │ │ │ -
105 auto childStorage (index_constant<k> = {}) const
│ │ │ │ -
106 {
│ │ │ │ -
107 return node().proxiedNode().template childStorage<k>();
│ │ │ │ -
108 }
│ │ │ │ -
│ │ │ │ -
109
│ │ │ │ -
111 template<std::size_t k, class ProxyChild>
│ │ │ │ -
│ │ │ │ -
112 void setChild (ProxyChild&& child, typename std::enable_if<lazy_enabled<k>::value,void*>::type = 0)
│ │ │ │ -
113 {
│ │ │ │ -
114 node().proxiedNode().template setChild<k>(std::forward<ProxyChild>(child));
│ │ │ │ -
115 }
│ │ │ │ -
│ │ │ │ -
116
│ │ │ │ -
│ │ │ │ -
117 const typename ProxiedNode::NodeStorage& nodeStorage () const
│ │ │ │ -
118 {
│ │ │ │ -
119 return node().proxiedNode().nodeStorage();
│ │ │ │ -
120 }
│ │ │ │ -
│ │ │ │ -
121
│ │ │ │ -
122 };
│ │ │ │ -
│ │ │ │ -
123
│ │ │ │ -
125
│ │ │ │ -
130 template<typename ProxiedNode>
│ │ │ │ -
│ │ │ │ -
131 class DynamicChildAccessors
│ │ │ │ -
132 : public StaticChildAccessors<ProxiedNode>
│ │ │ │ -
133 {
│ │ │ │ -
134
│ │ │ │ -
135 typedef ProxyNode<ProxiedNode> Node;
│ │ │ │ -
136
│ │ │ │ -
137 static const bool proxiedNodeIsConst = std::is_const<typename std::remove_reference<ProxiedNode>::type>::value;
│ │ │ │ -
138
│ │ │ │ -
139 template<bool enabled = !proxiedNodeIsConst>
│ │ │ │ -
140 typename std::enable_if<enabled,Node&>::type
│ │ │ │ -
141 node ()
│ │ │ │ -
142 {
│ │ │ │ -
143 return static_cast<Node&>(*this);
│ │ │ │ -
144 }
│ │ │ │ -
145
│ │ │ │ -
146 const Node& node () const
│ │ │ │ -
147 {
│ │ │ │ -
148 return static_cast<const Node&>(*this);
│ │ │ │ -
149 }
│ │ │ │ -
150
│ │ │ │ -
151 public:
│ │ │ │ -
152
│ │ │ │ -
155
│ │ │ │ -
157
│ │ │ │ -
160 template<bool enabled = !proxiedNodeIsConst,
│ │ │ │ -
161 typename std::enable_if<enabled, int>::type = 0>
│ │ │ │ -
│ │ │ │ -
162 auto& child (std::size_t i)
│ │ │ │ -
163 {
│ │ │ │ -
164 return node().proxiedNode().child(i);
│ │ │ │ -
165 }
│ │ │ │ -
│ │ │ │ -
166
│ │ │ │ -
168
│ │ │ │ -
│ │ │ │ -
171 const auto& child (std::size_t i) const
│ │ │ │ -
172 {
│ │ │ │ -
173 return node().proxiedNode().child(i);
│ │ │ │ -
174 }
│ │ │ │ -
│ │ │ │ -
175
│ │ │ │ -
177
│ │ │ │ -
180 template<bool enabled = !proxiedNodeIsConst,
│ │ │ │ -
181 typename std::enable_if<enabled, int>::type = 0>
│ │ │ │ -
│ │ │ │ -
182 auto childStorage (std::size_t i)
│ │ │ │ -
183 {
│ │ │ │ -
184 return node().proxiedNode().childStorage(i);
│ │ │ │ -
185 }
│ │ │ │ -
│ │ │ │ -
186
│ │ │ │ -
188
│ │ │ │ -
│ │ │ │ -
194 auto childStorage (std::size_t i) const
│ │ │ │ -
195 {
│ │ │ │ -
196 return node().proxiedNode().childStorage(i);
│ │ │ │ -
197 }
│ │ │ │ -
│ │ │ │ -
198
│ │ │ │ -
200 template<class ProxyChild, bool enabled = !proxiedNodeIsConst>
│ │ │ │ -
│ │ │ │ -
201 void setChild (std::size_t i, ProxyChild&& child, typename std::enable_if<enabled,void*>::type = 0)
│ │ │ │ -
202 {
│ │ │ │ -
203 node().proxiedNode().setChild(i, std::forward<ProxyChild>(child));
│ │ │ │ -
204 }
│ │ │ │ -
│ │ │ │ -
205
│ │ │ │ -
206 };
│ │ │ │ -
│ │ │ │ -
207
│ │ │ │ -
209 template<typename Node, typename NodeTag>
│ │ │ │ -
210 struct ProxyNodeBase;
│ │ │ │ +
99 } // end namespace Impl
│ │ │ │ +
100
│ │ │ │ +
101#endif // DOXYGEN
│ │ │ │ +
102
│ │ │ │ +
104
│ │ │ │ +
126 template<typename Node, typename... Indices>
│ │ │ │ +
127#ifdef DOXYGEN
│ │ │ │ +
│ │ │ │ +
128 ImplementationDefined child (Node&& node, Indices... indices)
│ │ │ │ +
129#else
│ │ │ │ +
130 decltype(auto) child (Node&& node, Indices... indices)
│ │ │ │ +
131#endif
│ │ │ │ +
132 {
│ │ │ │ +
133 return Impl::childImpl(std::forward<Node>(node),indices...);
│ │ │ │ +
134 }
│ │ │ │ +
│ │ │ │ +
135
│ │ │ │ +
136 template<typename Node, typename... Indices>
│ │ │ │ +
137#ifdef DOXYGEN
│ │ │ │ +
│ │ │ │ +
138 ImplementationDefined childStorage (Node&& node, Indices... indices)
│ │ │ │ +
139#else
│ │ │ │ +
140 auto childStorage (Node&& node, Indices... indices)
│ │ │ │ +
141#endif
│ │ │ │ +
142 {
│ │ │ │ +
143 static_assert(sizeof...(Indices) > 0, "childStorage() cannot be called with an empty list of child indices");
│ │ │ │ +
144 return Impl::childStorageImpl(&node,indices...);
│ │ │ │ +
145 }
│ │ │ │ +
│ │ │ │ +
146
│ │ │ │ +
148
│ │ │ │ +
171 template<typename Node, typename... Indices>
│ │ │ │ +
172#ifdef DOXYGEN
│ │ │ │ +
│ │ │ │ +
173 ImplementationDefined child (Node&& node, HybridTreePath<Indices...> treePath)
│ │ │ │ +
174#else
│ │ │ │ +
175 decltype(auto) child (Node&& node, HybridTreePath<Indices...> tp)
│ │ │ │ +
176#endif
│ │ │ │ +
177 {
│ │ │ │ +
178 return Impl::child(std::forward<Node>(node),tp,std::index_sequence_for<Indices...>{});
│ │ │ │ +
179 }
│ │ │ │ +
│ │ │ │ +
180
│ │ │ │ +
181 template<typename Node, typename... Indices>
│ │ │ │ +
182#ifdef DOXYGEN
│ │ │ │ +
183 ImplementationDefined child (Node&& node, HybridTreePath<Indices...> treePath)
│ │ │ │ +
184#else
│ │ │ │ +
185 auto childStorage (Node&& node, HybridTreePath<Indices...> tp)
│ │ │ │ +
186#endif
│ │ │ │ +
187 {
│ │ │ │ +
188 static_assert(sizeof...(Indices) > 0, "childStorage() cannot be called with an empty TreePath");
│ │ │ │ +
189 return Impl::childStorage(&node,tp,std::index_sequence_for<Indices...>{});
│ │ │ │ +
190 }
│ │ │ │ +
191
│ │ │ │ +
192
│ │ │ │ +
193#ifndef DOXYGEN
│ │ │ │ +
194
│ │ │ │ +
195 namespace impl {
│ │ │ │ +
196
│ │ │ │ +
197 template<typename T>
│ │ │ │ +
198 struct filter_void
│ │ │ │ +
199 {
│ │ │ │ +
200 using type = T;
│ │ │ │ +
201 };
│ │ │ │ +
202
│ │ │ │ +
203 template<>
│ │ │ │ +
204 struct filter_void<void>
│ │ │ │ +
205 {};
│ │ │ │ +
206
│ │ │ │ +
207 template<typename Node, std::size_t... indices>
│ │ │ │ +
208 struct _Child
│ │ │ │ +
209 : public filter_void<std::decay_t<decltype(child(std::declval<Node>(),index_constant<indices>{}...))>>
│ │ │ │ +
210 {};
│ │ │ │
211
│ │ │ │ -
213 template<typename Node>
│ │ │ │ -
│ │ │ │ -
214 struct ProxyNodeBase<Node,LeafNodeTag>
│ │ │ │ -
215 {
│ │ │ │ -
216 };
│ │ │ │ -
│ │ │ │ +
212 }
│ │ │ │ +
213
│ │ │ │ +
214#endif // DOXYGEN
│ │ │ │ +
215
│ │ │ │
217
│ │ │ │ -
219 template<typename Node>
│ │ │ │ -
│ │ │ │ -
220 struct ProxyNodeBase<Node,CompositeNodeTag>
│ │ │ │ -
221 : public StaticChildAccessors<Node>
│ │ │ │ -
222 {
│ │ │ │ -
223 typedef typename Node::ChildTypes ChildTypes;
│ │ │ │ -
224 typedef typename Node::NodeStorage NodeStorage;
│ │ │ │ -
225 };
│ │ │ │ -
│ │ │ │ +
224 template<typename Node, std::size_t... indices>
│ │ │ │ +
225 using Child = typename impl::_Child<Node,indices...>::type;
│ │ │ │
226
│ │ │ │ -
228 template<typename Node>
│ │ │ │ -
│ │ │ │ -
229 struct ProxyNodeBase<Node,PowerNodeTag>
│ │ │ │ -
230 : public DynamicChildAccessors<Node>
│ │ │ │ -
231 {
│ │ │ │ -
232 typedef typename Node::ChildType ChildType;
│ │ │ │ -
233 typedef typename Node::NodeStorage NodeStorage;
│ │ │ │ -
234 };
│ │ │ │ -
│ │ │ │ -
235
│ │ │ │ -
237 template<typename Node>
│ │ │ │ -
│ │ │ │ -
238 struct ProxyNodeBase<Node,DynamicPowerNodeTag>
│ │ │ │ -
239 : public DynamicChildAccessors<Node>
│ │ │ │ -
240 {
│ │ │ │ -
241 typedef typename Node::ChildType ChildType;
│ │ │ │ -
242 typedef typename Node::NodeStorage NodeStorage;
│ │ │ │ -
243 };
│ │ │ │ -
│ │ │ │ -
244
│ │ │ │ -
246
│ │ │ │ -
252 template<typename Node>
│ │ │ │ -
│ │ │ │ -
253 class ProxyNode
│ │ │ │ -
254 : public ProxyNodeBase<Node,NodeTag<Node>>
│ │ │ │ -
255 {
│ │ │ │ -
256 static const bool proxiedNodeIsConst = std::is_const<typename std::remove_reference<Node>::type>::value;
│ │ │ │ -
257
│ │ │ │ -
258 template <class N>
│ │ │ │ -
259 using HasStaticDegree = index_constant<N::degree()>;
│ │ │ │ -
260
│ │ │ │ -
261 template <class N>
│ │ │ │ -
262 static constexpr bool hasStaticDegree = Std::is_detected<HasStaticDegree, N>::value;
│ │ │ │ -
263
│ │ │ │ -
264 // accessor mixins need to be friends for access to proxiedNode()
│ │ │ │ -
265 friend class StaticChildAccessors<Node>;
│ │ │ │ -
266 friend class DynamicChildAccessors<Node>;
│ │ │ │ -
267
│ │ │ │ -
268 public:
│ │ │ │ -
269
│ │ │ │ -
270 typedef Node ProxiedNode;
│ │ │ │ -
271
│ │ │ │ -
272 typedef Dune::TypeTree::NodeTag<Node> NodeTag;
│ │ │ │ -
273
│ │ │ │ -
275 static const bool isLeaf = Node::isLeaf;
│ │ │ │ +
227
│ │ │ │ +
228#ifndef DOXYGEN
│ │ │ │ +
229
│ │ │ │ +
230 namespace impl {
│ │ │ │ +
231
│ │ │ │ +
232 template<typename Node, typename TreePath>
│ │ │ │ +
233 struct _ChildForTreePath
│ │ │ │ +
234 {
│ │ │ │ +
235 using type = typename std::decay<decltype(child(std::declval<Node>(),std::declval<TreePath>()))>::type;
│ │ │ │ +
236 };
│ │ │ │ +
237
│ │ │ │ +
238 }
│ │ │ │ +
239
│ │ │ │ +
240#endif // DOXYGEN
│ │ │ │ +
241
│ │ │ │ +
243
│ │ │ │ +
251 template<typename Node, typename TreePath>
│ │ │ │ +
252 using ChildForTreePath = typename impl::_ChildForTreePath<Node,TreePath>::type;
│ │ │ │ +
253
│ │ │ │ +
254
│ │ │ │ +
255#ifndef DOXYGEN
│ │ │ │ +
256
│ │ │ │ +
257 namespace impl {
│ │ │ │ +
258
│ │ │ │ +
259 // By default, types are flat indices if they are integral
│ │ │ │ +
260 template<typename T>
│ │ │ │ +
261 struct _is_flat_index
│ │ │ │ +
262 {
│ │ │ │ +
263 using type = std::is_integral<T>;
│ │ │ │ +
264 };
│ │ │ │ +
265
│ │ │ │ +
266 // And so is any index_constant
│ │ │ │ +
267 template<std::size_t i>
│ │ │ │ +
268 struct _is_flat_index<index_constant<i>>
│ │ │ │ +
269 {
│ │ │ │ +
270 using type = std::true_type;
│ │ │ │ +
271 };
│ │ │ │ +
272
│ │ │ │ +
273 }
│ │ │ │ +
274
│ │ │ │ +
275#endif // DOXYGEN
│ │ │ │
276
│ │ │ │ -
278 static const bool isPower = Node::isPower;
│ │ │ │ -
279
│ │ │ │ -
281 static const bool isComposite = Node::isComposite;
│ │ │ │ -
282
│ │ │ │ -
283 template <class N = Node,
│ │ │ │ -
284 std::enable_if_t<hasStaticDegree<N>, int> = 0>
│ │ │ │ -
│ │ │ │ -
285 static constexpr auto degree ()
│ │ │ │ -
286 {
│ │ │ │ -
287 return N::degree();
│ │ │ │ -
288 }
│ │ │ │ -
│ │ │ │ +
278 /*
│ │ │ │ +
279 * This type trait can be used to check whether T is a flat index (i.e. either `std::size_t`
│ │ │ │ +
280 * or `index_constant`). The type trait normalizes T before doing the check, so it will also
│ │ │ │ +
281 * work correctly for references and cv-qualified types.
│ │ │ │ +
282 */
│ │ │ │ +
283 template<typename T>
│ │ │ │ +
284 using is_flat_index = typename impl::_is_flat_index<std::decay_t<T>>::type;
│ │ │ │ +
285
│ │ │ │ +
286#ifndef DOXYGEN
│ │ │ │ +
287
│ │ │ │ +
288 namespace impl {
│ │ │ │
289
│ │ │ │ -
290 template <class N = Node,
│ │ │ │ -
291 std::enable_if_t<not hasStaticDegree<N>, int> = 0>
│ │ │ │ -
│ │ │ │ -
292 auto degree () const
│ │ │ │ -
293 {
│ │ │ │ -
294 return proxiedNode().degree();
│ │ │ │ -
295 }
│ │ │ │ -
│ │ │ │ -
296
│ │ │ │ -
297
│ │ │ │ -
298 protected:
│ │ │ │ -
299
│ │ │ │ +
290 // helper function for check in member child() functions that tolerates being passed something that
│ │ │ │ +
291 // isn't a TreePath. It will just return 0 in that case
│ │ │ │ +
292
│ │ │ │ +
293 template<typename T>
│ │ │ │ +
294 constexpr typename std::enable_if<
│ │ │ │ +
295 Dune::TypeTree::is_flat_index<T>::value,
│ │ │ │ +
296 bool
│ │ │ │ +
297 >::type
│ │ │ │ +
298 _non_empty_tree_path (T)
│ │ │ │ +
299 {
│ │ │ │ +
300 return false;
│ │ │ │ +
301 }
│ │ │ │
302
│ │ │ │ -
304 template<bool enabled = !proxiedNodeIsConst>
│ │ │ │ -
305 typename std::enable_if<enabled,Node&>::type
│ │ │ │ -
│ │ │ │ -
306 proxiedNode ()
│ │ │ │ -
307 {
│ │ │ │ -
308 return *_node;
│ │ │ │ -
309 }
│ │ │ │ -
│ │ │ │ -
310
│ │ │ │ -
│ │ │ │ -
312 const Node& proxiedNode () const
│ │ │ │ -
313 {
│ │ │ │ -
314 return *_node;
│ │ │ │ -
315 }
│ │ │ │ -
│ │ │ │ +
303 template<typename T>
│ │ │ │ +
304 constexpr typename std::enable_if<
│ │ │ │ +
305 !Dune::TypeTree::is_flat_index<T>::value,
│ │ │ │ +
306 bool
│ │ │ │ +
307 >::type
│ │ │ │ +
308 _non_empty_tree_path (T t)
│ │ │ │ +
309 {
│ │ │ │ +
310 return treePathSize(t) > 0;
│ │ │ │ +
311 }
│ │ │ │ +
312
│ │ │ │ +
313 }
│ │ │ │ +
314
│ │ │ │ +
315#endif // DOXYGEN
│ │ │ │
316
│ │ │ │ -
318 template<bool enabled = !proxiedNodeIsConst>
│ │ │ │ -
319 typename std::enable_if<enabled,std::shared_ptr<Node> >::type
│ │ │ │ -
│ │ │ │ -
320 proxiedNodeStorage ()
│ │ │ │ -
321 {
│ │ │ │ -
322 return _node;
│ │ │ │ -
323 }
│ │ │ │ -
│ │ │ │ -
324
│ │ │ │ -
│ │ │ │ -
326 std::shared_ptr<const Node> proxiedNodeStorage () const
│ │ │ │ -
327 {
│ │ │ │ -
328 return _node;
│ │ │ │ -
329 }
│ │ │ │ -
│ │ │ │ -
330
│ │ │ │ -
332
│ │ │ │ -
335
│ │ │ │ -
│ │ │ │ -
336 ProxyNode (Node& node)
│ │ │ │ -
337 : _node(stackobject_to_shared_ptr(node))
│ │ │ │ -
338 {}
│ │ │ │ -
│ │ │ │ -
339
│ │ │ │ -
│ │ │ │ -
340 ProxyNode (std::shared_ptr<Node> node)
│ │ │ │ -
341 : _node(std::move(node))
│ │ │ │ -
342 {}
│ │ │ │ -
│ │ │ │ -
343
│ │ │ │ -
345
│ │ │ │ -
346 private:
│ │ │ │ -
347
│ │ │ │ -
348 std::shared_ptr<Node> _node;
│ │ │ │ -
349 };
│ │ │ │ -
│ │ │ │ -
350
│ │ │ │ -
352
│ │ │ │ -
353 } // namespace TypeTree
│ │ │ │ -
354} //namespace Dune
│ │ │ │ -
355
│ │ │ │ -
356#endif // DUNE_TYPETREE_PROXYNODE_HH
│ │ │ │ - │ │ │ │ - │ │ │ │ -
Dune::TypeTree::NodeTag
typename std::decay_t< Node >::NodeTag NodeTag
Returns the node tag of the given Node.
Definition nodeinterface.hh:70
│ │ │ │ +
318
│ │ │ │ +
319 } // namespace TypeTree
│ │ │ │ +
320} //namespace Dune
│ │ │ │ +
321
│ │ │ │ +
322#endif // DUNE_TYPETREE_CHILDEXTRACTION_HH
│ │ │ │ + │ │ │ │ + │ │ │ │ +
Dune::TypeTree::is_flat_index
typename impl::_is_flat_index< std::decay_t< T > >::type is_flat_index
Type trait that determines whether T is a flat index in the context of child extraction.
Definition childextraction.hh:284
│ │ │ │ +
Dune::TypeTree::childStorage
ImplementationDefined childStorage(Node &&node, Indices... indices)
Definition childextraction.hh:138
│ │ │ │ +
Dune::TypeTree::Child
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
│ │ │ │ +
Dune::TypeTree::child
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
│ │ │ │ +
Dune::TypeTree::ChildForTreePath
typename impl::_ChildForTreePath< Node, TreePath >::type ChildForTreePath
Template alias for the type of a child node given by a TreePath or a HybridTreePath type.
Definition childextraction.hh:252
│ │ │ │ +
Dune::TypeTree::treePathSize
constexpr std::size_t treePathSize(const HybridTreePath< T... > &)
Returns the size (number of components) of the given HybridTreePath.
Definition treepath.hh:334
│ │ │ │ +
Dune::TypeTree::treePath
constexpr auto treePath(const T &... t)
Constructs a new HybridTreePath from the given indices.
Definition treepath.hh:326
│ │ │ │
Dune
Definition accumulate_static.hh:16
│ │ │ │ -
Dune::TypeTree::LeafNodeTag
Tag designating a leaf node.
Definition nodetags.hh:18
│ │ │ │ -
Dune::TypeTree::PowerNodeTag
Tag designating a power node.
Definition nodetags.hh:21
│ │ │ │ -
Dune::TypeTree::DynamicPowerNodeTag
Tag designating a power node with runtime degree.
Definition nodetags.hh:24
│ │ │ │ -
Dune::TypeTree::CompositeNodeTag
Tag designating a composite node.
Definition nodetags.hh:27
│ │ │ │ -
Dune::TypeTree::ProxyNode
Base class for nodes acting as a proxy for an existing node.
Definition proxynode.hh:255
│ │ │ │ -
Dune::TypeTree::ProxyNode::ProxyNode
ProxyNode(Node &node)
Definition proxynode.hh:336
│ │ │ │ -
Dune::TypeTree::ProxyNode::NodeTag
Dune::TypeTree::NodeTag< Node > NodeTag
Definition proxynode.hh:272
│ │ │ │ -
Dune::TypeTree::ProxyNode::isComposite
static const bool isComposite
Mark this class as a composite in the dune-typetree.
Definition proxynode.hh:281
│ │ │ │ -
Dune::TypeTree::ProxyNode::isLeaf
static const bool isLeaf
Mark this class as non leaf in the dune-typetree.
Definition proxynode.hh:275
│ │ │ │ -
Dune::TypeTree::ProxyNode::isPower
static const bool isPower
Mark this class as a non power in the dune-typetree.
Definition proxynode.hh:278
│ │ │ │ -
Dune::TypeTree::ProxyNode::degree
auto degree() const
Definition proxynode.hh:292
│ │ │ │ -
Dune::TypeTree::ProxyNode::proxiedNode
std::enable_if< enabled, Node & >::type proxiedNode()
Returns the proxied node.
Definition proxynode.hh:306
│ │ │ │ -
Dune::TypeTree::ProxyNode::proxiedNodeStorage
std::shared_ptr< const Node > proxiedNodeStorage() const
Returns the storage of the proxied node (const version).
Definition proxynode.hh:326
│ │ │ │ -
Dune::TypeTree::ProxyNode::ProxiedNode
Node ProxiedNode
Definition proxynode.hh:270
│ │ │ │ -
Dune::TypeTree::ProxyNode::proxiedNodeStorage
std::enable_if< enabled, std::shared_ptr< Node > >::type proxiedNodeStorage()
Returns the storage of the proxied node.
Definition proxynode.hh:320
│ │ │ │ -
Dune::TypeTree::ProxyNode::degree
static constexpr auto degree()
Definition proxynode.hh:285
│ │ │ │ -
Dune::TypeTree::ProxyNode::ProxyNode
ProxyNode(std::shared_ptr< Node > node)
Definition proxynode.hh:340
│ │ │ │ -
Dune::TypeTree::ProxyNode::proxiedNode
const Node & proxiedNode() const
Returns the proxied node (const version).
Definition proxynode.hh:312
│ │ │ │ -
Dune::TypeTree::StaticChildAccessors
Mixin class providing methods for child access with compile-time parameter.
Definition proxynode.hh:30
│ │ │ │ -
Dune::TypeTree::StaticChildAccessors::child
auto & child(index_constant< k >={})
Returns the i-th child.
Definition proxynode.hh:71
│ │ │ │ -
Dune::TypeTree::StaticChildAccessors::setChild
void setChild(ProxyChild &&child, typename std::enable_if< lazy_enabled< k >::value, void * >::type=0)
Sets the i-th child to the passed-in value.
Definition proxynode.hh:112
│ │ │ │ -
Dune::TypeTree::StaticChildAccessors::nodeStorage
const ProxiedNode::NodeStorage & nodeStorage() const
Definition proxynode.hh:117
│ │ │ │ -
Dune::TypeTree::StaticChildAccessors::childStorage
auto childStorage(index_constant< k >={})
Returns the storage of the i-th child.
Definition proxynode.hh:92
│ │ │ │ -
Dune::TypeTree::StaticChildAccessors::child
const auto & child(index_constant< k >={}) const
Returns the i-th child (const version).
Definition proxynode.hh:81
│ │ │ │ -
Dune::TypeTree::StaticChildAccessors::childStorage
auto childStorage(index_constant< k >={}) const
Returns the storage of the i-th child (const version).
Definition proxynode.hh:105
│ │ │ │ -
Dune::TypeTree::StaticChildAccessors::Child
Access to the type and storage type of the i-th child.
Definition proxynode.hh:60
│ │ │ │ -
Dune::TypeTree::DynamicChildAccessors
Mixin class providing methods for child access with run-time parameter.
Definition proxynode.hh:133
│ │ │ │ -
Dune::TypeTree::DynamicChildAccessors::child
auto & child(std::size_t i)
Returns the i-th child.
Definition proxynode.hh:162
│ │ │ │ -
Dune::TypeTree::DynamicChildAccessors::childStorage
auto childStorage(std::size_t i) const
Returns the storage of the i-th child (const version).
Definition proxynode.hh:194
│ │ │ │ -
Dune::TypeTree::DynamicChildAccessors::setChild
void setChild(std::size_t i, ProxyChild &&child, typename std::enable_if< enabled, void * >::type=0)
Sets the i-th child to the passed-in value.
Definition proxynode.hh:201
│ │ │ │ -
Dune::TypeTree::DynamicChildAccessors::child
const auto & child(std::size_t i) const
Returns the i-th child (const version).
Definition proxynode.hh:171
│ │ │ │ -
Dune::TypeTree::DynamicChildAccessors::childStorage
auto childStorage(std::size_t i)
Returns the storage of the i-th child.
Definition proxynode.hh:182
│ │ │ │ -
Dune::TypeTree::ProxyNodeBase
Tag-based dispatch to appropriate base class that provides necessary functionality.
Definition proxynode.hh:210
│ │ │ │ -
Dune::TypeTree::ProxyNodeBase< Node, CompositeNodeTag >::NodeStorage
Node::NodeStorage NodeStorage
Definition proxynode.hh:224
│ │ │ │ -
Dune::TypeTree::ProxyNodeBase< Node, CompositeNodeTag >::ChildTypes
Node::ChildTypes ChildTypes
Definition proxynode.hh:223
│ │ │ │ -
Dune::TypeTree::ProxyNodeBase< Node, PowerNodeTag >::NodeStorage
Node::NodeStorage NodeStorage
Definition proxynode.hh:233
│ │ │ │ -
Dune::TypeTree::ProxyNodeBase< Node, PowerNodeTag >::ChildType
Node::ChildType ChildType
Definition proxynode.hh:232
│ │ │ │ -
Dune::TypeTree::ProxyNodeBase< Node, DynamicPowerNodeTag >::NodeStorage
Node::NodeStorage NodeStorage
Definition proxynode.hh:242
│ │ │ │ -
Dune::TypeTree::ProxyNodeBase< Node, DynamicPowerNodeTag >::ChildType
Node::ChildType ChildType
Definition proxynode.hh:241
│ │ │ │ +
Dune::TypeTree::HybridTreePath
A hybrid version of TreePath that supports both compile time and run time indices.
Definition treepath.hh:158
│ │ │ │
│ │ │ │ │ │ │ │
│ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,446 +1,323 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -proxynode.hh │ │ │ │ │ +childextraction.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: │ │ │ │ │ +1// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- │ │ │ │ │ +2// vi: set et ts=8 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_PROXYNODE_HH │ │ │ │ │ -7#define DUNE_TYPETREE_PROXYNODE_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_CHILDEXTRACTION_HH │ │ │ │ │ +7#define DUNE_TYPETREE_CHILDEXTRACTION_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 │ │ │ │ │ -13#include │ │ │ │ │ -14#include │ │ │ │ │ -15 │ │ │ │ │ -16namespace _D_u_n_e { │ │ │ │ │ -17 namespace TypeTree { │ │ │ │ │ -18 │ │ │ │ │ -24 template │ │ │ │ │ -25 class ProxyNode; │ │ │ │ │ -26 │ │ │ │ │ -28 template │ │ │ │ │ -_2_9 class _S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s │ │ │ │ │ -30 { │ │ │ │ │ -31 │ │ │ │ │ -32 static const bool proxiedNodeIsConst = std::is_const::type>::value; │ │ │ │ │ -33 │ │ │ │ │ -34 template │ │ │ │ │ -35 struct lazy_enabled │ │ │ │ │ +10#include │ │ │ │ │ +11 │ │ │ │ │ +12#include │ │ │ │ │ +13#include │ │ │ │ │ +14#include │ │ │ │ │ +15#include │ │ │ │ │ +16 │ │ │ │ │ +17#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> │ │ │ │ │ +18#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_e_e_p_a_t_h_._h_h> │ │ │ │ │ +19 │ │ │ │ │ +20 │ │ │ │ │ +21namespace _D_u_n_e { │ │ │ │ │ +22 namespace TypeTree { │ │ │ │ │ +23 │ │ │ │ │ +28 │ │ │ │ │ +29#ifndef DOXYGEN │ │ │ │ │ +30 │ │ │ │ │ +31 namespace Impl { │ │ │ │ │ +32 │ │ │ │ │ +33 // check at run time whether index is a valid child index │ │ │ │ │ +34 template │ │ │ │ │ +35 std::true_type checkChildIndex (Node const& node, Index i) │ │ │ │ │ 36 { │ │ │ │ │ -37 static const bool value = !proxiedNodeIsConst; │ │ │ │ │ -38 }; │ │ │ │ │ -39 │ │ │ │ │ -40 typedef _P_r_o_x_y_N_o_d_e_<_P_r_o_x_i_e_d_N_o_d_e_> _N_o_d_e; │ │ │ │ │ -41 │ │ │ │ │ -42 template │ │ │ │ │ -43 typename std::enable_if::type │ │ │ │ │ -44 node () │ │ │ │ │ -45 { │ │ │ │ │ -46 return static_cast<_N_o_d_e&>(*this); │ │ │ │ │ +37 assert(std::size_t(i) < node.degree() && "Child index out of range"); │ │ │ │ │ +38 return {}; │ │ │ │ │ +39 } │ │ │ │ │ +40 │ │ │ │ │ +41 // check at compile time whether index is a valid index │ │ │ │ │ +42 template │ │ │ │ │ +43 std::bool_constant<(i < Node::degree())> checkChildIndex (Node const& node, │ │ │ │ │ +index_constant) │ │ │ │ │ +44 { │ │ │ │ │ +45 static_assert(i < Node::degree(), "Child index out of range"); │ │ │ │ │ +46 return {}; │ │ │ │ │ 47 } │ │ │ │ │ 48 │ │ │ │ │ -49 const _N_o_d_e& node () const │ │ │ │ │ -50 { │ │ │ │ │ -51 return static_cast(*this); │ │ │ │ │ -52 } │ │ │ │ │ -53 │ │ │ │ │ -54 public: │ │ │ │ │ -55 │ │ │ │ │ -57 template │ │ │ │ │ -_5_8 struct _C_h_i_l_d │ │ │ │ │ -59 : public ProxiedNode::template _C_h_i_l_d │ │ │ │ │ -60 {}; │ │ │ │ │ -61 │ │ │ │ │ -64 │ │ │ │ │ -66 │ │ │ │ │ -69 template::value, int>::type = 0> │ │ │ │ │ -_7_1 auto& _c_h_i_l_d (index_constant = {}) │ │ │ │ │ -72 { │ │ │ │ │ -73 return node().proxiedNode().template child(); │ │ │ │ │ -74 } │ │ │ │ │ -75 │ │ │ │ │ -77 │ │ │ │ │ -80 template │ │ │ │ │ -_8_1 const auto& _c_h_i_l_d (index_constant = {}) const │ │ │ │ │ -82 { │ │ │ │ │ -83 return node().proxiedNode().template child(); │ │ │ │ │ -84 } │ │ │ │ │ -85 │ │ │ │ │ -87 │ │ │ │ │ -90 template::value, int>::type = 0> │ │ │ │ │ -_9_2 auto _c_h_i_l_d_S_t_o_r_a_g_e (index_constant = {}) │ │ │ │ │ -93 { │ │ │ │ │ -94 return node().proxiedNode().template childStorage(); │ │ │ │ │ -95 } │ │ │ │ │ -96 │ │ │ │ │ +49 // finally return the node itself if no further indices are provided. Break │ │ │ │ │ +condition │ │ │ │ │ +50 // for the recursion over the node childs. │ │ │ │ │ +51 template │ │ │ │ │ +52 decltype(auto) childImpl (Node&& node) │ │ │ │ │ +53 { │ │ │ │ │ +54 return std::forward(node); │ │ │ │ │ +55 } │ │ │ │ │ +56 │ │ │ │ │ +57 template │ │ │ │ │ +58 auto childStorageImpl (NodePtr&& nodePtr) │ │ │ │ │ +59 { │ │ │ │ │ +60 return std::forward(nodePtr); │ │ │ │ │ +61 } │ │ │ │ │ +62 │ │ │ │ │ +63 // recursively call `node.child(...)` with the given indices │ │ │ │ │ +64 template │ │ │ │ │ +65 decltype(auto) childImpl (Node&& node, I0 i0, [[maybe_unused]] I... i) │ │ │ │ │ +66 { │ │ │ │ │ +67 auto valid = checkChildIndex(node,i0); │ │ │ │ │ +68 if constexpr (valid) │ │ │ │ │ +69 return childImpl(node.child(i0),i...); │ │ │ │ │ +70 else │ │ │ │ │ +71 return; │ │ │ │ │ +72 } │ │ │ │ │ +73 │ │ │ │ │ +74 // recursively call `node.childStorage(...)` with the given indices │ │ │ │ │ +75 template │ │ │ │ │ +76 decltype(auto) childStorageImpl (NodePtr&& nodePtr, I0 i0, [[maybe_unused]] │ │ │ │ │ +I... i) │ │ │ │ │ +77 { │ │ │ │ │ +78 auto valid = checkChildIndex(*nodePtr,i0); │ │ │ │ │ +79 if constexpr (valid) │ │ │ │ │ +80 return childStorageImpl(nodePtr->childStorage(i0),i...); │ │ │ │ │ +81 else │ │ │ │ │ +82 return; │ │ │ │ │ +83 } │ │ │ │ │ +84 │ │ │ │ │ +85 // forward to the impl methods by extracting the indices from the treepath │ │ │ │ │ +86 template │ │ │ │ │ +87 decltype(auto) _c_h_i_l_d (Node&& node, [[maybe_unused]] │ │ │ │ │ +HybridTreePath tp, std::index_sequence) │ │ │ │ │ +88 { │ │ │ │ │ +89 return childImpl(std::forward(node),treePathEntry(tp)...); │ │ │ │ │ +90 } │ │ │ │ │ +91 │ │ │ │ │ +92 // forward to the impl methods by extracting the indices from the treepath │ │ │ │ │ +93 template │ │ │ │ │ +94 decltype(auto) _c_h_i_l_d_S_t_o_r_a_g_e (NodePtr&& nodePtr, [[maybe_unused]] │ │ │ │ │ +HybridTreePath tp, std::index_sequence) │ │ │ │ │ +95 { │ │ │ │ │ +96 return childStorageImpl(std::forward(nodePtr),treePathEntry │ │ │ │ │ +(tp)...); │ │ │ │ │ +97 } │ │ │ │ │ 98 │ │ │ │ │ -104 template │ │ │ │ │ -_1_0_5 auto _c_h_i_l_d_S_t_o_r_a_g_e (index_constant = {}) const │ │ │ │ │ -106 { │ │ │ │ │ -107 return node().proxiedNode().template childStorage(); │ │ │ │ │ -108 } │ │ │ │ │ -109 │ │ │ │ │ -111 template │ │ │ │ │ -_1_1_2 void _s_e_t_C_h_i_l_d (ProxyChild&& _c_h_i_l_d, typename std:: │ │ │ │ │ -enable_if::value,void*>::type = 0) │ │ │ │ │ -113 { │ │ │ │ │ -114 node().proxiedNode().template setChild(std::forward(_c_h_i_l_d)); │ │ │ │ │ -115 } │ │ │ │ │ -116 │ │ │ │ │ -_1_1_7 const typename ProxiedNode::NodeStorage& _n_o_d_e_S_t_o_r_a_g_e () const │ │ │ │ │ -118 { │ │ │ │ │ -119 return node().proxiedNode().nodeStorage(); │ │ │ │ │ -120 } │ │ │ │ │ -121 │ │ │ │ │ -122 }; │ │ │ │ │ -123 │ │ │ │ │ -125 │ │ │ │ │ -130 template │ │ │ │ │ -_1_3_1 class _D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s │ │ │ │ │ -132 : public _S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s │ │ │ │ │ -133 { │ │ │ │ │ -134 │ │ │ │ │ -135 typedef _P_r_o_x_y_N_o_d_e_<_P_r_o_x_i_e_d_N_o_d_e_> _N_o_d_e; │ │ │ │ │ -136 │ │ │ │ │ -137 static const bool proxiedNodeIsConst = std::is_const::type>::value; │ │ │ │ │ -138 │ │ │ │ │ -139 template │ │ │ │ │ -140 typename std::enable_if::type │ │ │ │ │ -141 node () │ │ │ │ │ +99 } // end namespace Impl │ │ │ │ │ +100 │ │ │ │ │ +101#endif // DOXYGEN │ │ │ │ │ +102 │ │ │ │ │ +104 │ │ │ │ │ +126 template │ │ │ │ │ +127#ifdef DOXYGEN │ │ │ │ │ +_1_2_8 ImplementationDefined _c_h_i_l_d (Node&& node, Indices... indices) │ │ │ │ │ +129#else │ │ │ │ │ +130 decltype(auto) _c_h_i_l_d (Node&& node, Indices... indices) │ │ │ │ │ +131#endif │ │ │ │ │ +132 { │ │ │ │ │ +133 return Impl::childImpl(std::forward(node),indices...); │ │ │ │ │ +134 } │ │ │ │ │ +135 │ │ │ │ │ +136 template │ │ │ │ │ +137#ifdef DOXYGEN │ │ │ │ │ +_1_3_8 ImplementationDefined _c_h_i_l_d_S_t_o_r_a_g_e (Node&& node, Indices... indices) │ │ │ │ │ +139#else │ │ │ │ │ +140 auto _c_h_i_l_d_S_t_o_r_a_g_e (Node&& node, Indices... indices) │ │ │ │ │ +141#endif │ │ │ │ │ 142 { │ │ │ │ │ -143 return static_cast<_N_o_d_e&>(*this); │ │ │ │ │ -144 } │ │ │ │ │ -145 │ │ │ │ │ -146 const _N_o_d_e& node () const │ │ │ │ │ -147 { │ │ │ │ │ -148 return static_cast(*this); │ │ │ │ │ -149 } │ │ │ │ │ -150 │ │ │ │ │ -151 public: │ │ │ │ │ -152 │ │ │ │ │ -155 │ │ │ │ │ -157 │ │ │ │ │ -160 template::type = 0> │ │ │ │ │ -_1_6_2 auto& _c_h_i_l_d (std::size_t i) │ │ │ │ │ -163 { │ │ │ │ │ -164 return node().proxiedNode().child(i); │ │ │ │ │ -165 } │ │ │ │ │ -166 │ │ │ │ │ -168 │ │ │ │ │ -_1_7_1 const auto& _c_h_i_l_d (std::size_t i) const │ │ │ │ │ -172 { │ │ │ │ │ -173 return node().proxiedNode().child(i); │ │ │ │ │ -174 } │ │ │ │ │ -175 │ │ │ │ │ -177 │ │ │ │ │ -180 template::type = 0> │ │ │ │ │ -_1_8_2 auto _c_h_i_l_d_S_t_o_r_a_g_e (std::size_t i) │ │ │ │ │ -183 { │ │ │ │ │ -184 return node().proxiedNode().childStorage(i); │ │ │ │ │ -185 } │ │ │ │ │ -186 │ │ │ │ │ -188 │ │ │ │ │ -_1_9_4 auto _c_h_i_l_d_S_t_o_r_a_g_e (std::size_t i) const │ │ │ │ │ -195 { │ │ │ │ │ -196 return node().proxiedNode().childStorage(i); │ │ │ │ │ -197 } │ │ │ │ │ -198 │ │ │ │ │ -200 template │ │ │ │ │ -_2_0_1 void _s_e_t_C_h_i_l_d (std::size_t i, ProxyChild&& _c_h_i_l_d, typename std:: │ │ │ │ │ -enable_if::type = 0) │ │ │ │ │ -202 { │ │ │ │ │ -203 node().proxiedNode().setChild(i, std::forward(_c_h_i_l_d)); │ │ │ │ │ -204 } │ │ │ │ │ -205 │ │ │ │ │ -206 }; │ │ │ │ │ -207 │ │ │ │ │ -209 template │ │ │ │ │ -_2_1_0 struct _P_r_o_x_y_N_o_d_e_B_a_s_e; │ │ │ │ │ +143 static_assert(sizeof...(Indices) > 0, "childStorage() cannot be called with │ │ │ │ │ +an empty list of child indices"); │ │ │ │ │ +144 return Impl::childStorageImpl(&node,indices...); │ │ │ │ │ +145 } │ │ │ │ │ +146 │ │ │ │ │ +148 │ │ │ │ │ +171 template │ │ │ │ │ +172#ifdef DOXYGEN │ │ │ │ │ +_1_7_3 ImplementationDefined _c_h_i_l_d (Node&& node, _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_I_n_d_i_c_e_s_._._._> │ │ │ │ │ +_t_r_e_e_P_a_t_h) │ │ │ │ │ +174#else │ │ │ │ │ +175 decltype(auto) _c_h_i_l_d (Node&& node, _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_I_n_d_i_c_e_s_._._._> tp) │ │ │ │ │ +176#endif │ │ │ │ │ +177 { │ │ │ │ │ +178 return Impl::child(std::forward(node),tp,std:: │ │ │ │ │ +index_sequence_for{}); │ │ │ │ │ +179 } │ │ │ │ │ +180 │ │ │ │ │ +181 template │ │ │ │ │ +182#ifdef DOXYGEN │ │ │ │ │ +183 ImplementationDefined _c_h_i_l_d (Node&& node, HybridTreePath │ │ │ │ │ +_t_r_e_e_P_a_t_h) │ │ │ │ │ +184#else │ │ │ │ │ +185 auto _c_h_i_l_d_S_t_o_r_a_g_e (Node&& node, HybridTreePath tp) │ │ │ │ │ +186#endif │ │ │ │ │ +187 { │ │ │ │ │ +188 static_assert(sizeof...(Indices) > 0, "childStorage() cannot be called with │ │ │ │ │ +an empty TreePath"); │ │ │ │ │ +189 return Impl::childStorage(&node,tp,std::index_sequence_for{}); │ │ │ │ │ +190 } │ │ │ │ │ +191 │ │ │ │ │ +192 │ │ │ │ │ +193#ifndef DOXYGEN │ │ │ │ │ +194 │ │ │ │ │ +195 namespace impl { │ │ │ │ │ +196 │ │ │ │ │ +197 template │ │ │ │ │ +198 struct filter_void │ │ │ │ │ +199 { │ │ │ │ │ +200 using type = T; │ │ │ │ │ +201 }; │ │ │ │ │ +202 │ │ │ │ │ +203 template<> │ │ │ │ │ +204 struct filter_void │ │ │ │ │ +205 {}; │ │ │ │ │ +206 │ │ │ │ │ +207 template │ │ │ │ │ +208 struct _Child │ │ │ │ │ +209 : public filter_void │ │ │ │ │ +(),index_constant{}...))>> │ │ │ │ │ +210 {}; │ │ │ │ │ 211 │ │ │ │ │ -213 template │ │ │ │ │ -_2_1_4 struct _P_r_o_x_y_N_o_d_e_B_a_s_e │ │ │ │ │ -215 { │ │ │ │ │ -216 }; │ │ │ │ │ +212 } │ │ │ │ │ +213 │ │ │ │ │ +214#endif // DOXYGEN │ │ │ │ │ +215 │ │ │ │ │ 217 │ │ │ │ │ -219 template │ │ │ │ │ -_2_2_0 struct _P_r_o_x_y_N_o_d_e_B_a_s_e<_N_o_d_e,_C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g> │ │ │ │ │ -221 : public _S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s │ │ │ │ │ -222 { │ │ │ │ │ -_2_2_3 typedef typename Node::ChildTypes _C_h_i_l_d_T_y_p_e_s; │ │ │ │ │ -_2_2_4 typedef typename Node::NodeStorage _N_o_d_e_S_t_o_r_a_g_e; │ │ │ │ │ -225 }; │ │ │ │ │ +224 template │ │ │ │ │ +_2_2_5 using _C_h_i_l_d = typename impl::_Child::type; │ │ │ │ │ 226 │ │ │ │ │ -228 template │ │ │ │ │ -_2_2_9 struct _P_r_o_x_y_N_o_d_e_B_a_s_e<_N_o_d_e,_P_o_w_e_r_N_o_d_e_T_a_g> │ │ │ │ │ -230 : public _D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s │ │ │ │ │ -231 { │ │ │ │ │ -_2_3_2 typedef typename Node::ChildType _C_h_i_l_d_T_y_p_e; │ │ │ │ │ -_2_3_3 typedef typename Node::NodeStorage _N_o_d_e_S_t_o_r_a_g_e; │ │ │ │ │ -234 }; │ │ │ │ │ -235 │ │ │ │ │ -237 template │ │ │ │ │ -_2_3_8 struct _P_r_o_x_y_N_o_d_e_B_a_s_e<_N_o_d_e,_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g> │ │ │ │ │ -239 : public _D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s │ │ │ │ │ -240 { │ │ │ │ │ -_2_4_1 typedef typename Node::ChildType _C_h_i_l_d_T_y_p_e; │ │ │ │ │ -_2_4_2 typedef typename Node::NodeStorage _N_o_d_e_S_t_o_r_a_g_e; │ │ │ │ │ -243 }; │ │ │ │ │ -244 │ │ │ │ │ -246 │ │ │ │ │ -252 template │ │ │ │ │ -_2_5_3 class _P_r_o_x_y_N_o_d_e │ │ │ │ │ -254 : public _P_r_o_x_y_N_o_d_e_B_a_s_e> │ │ │ │ │ -255 { │ │ │ │ │ -256 static const bool proxiedNodeIsConst = std::is_const::type>::value; │ │ │ │ │ -257 │ │ │ │ │ -258 template │ │ │ │ │ -259 using HasStaticDegree = index_constant; │ │ │ │ │ -260 │ │ │ │ │ -261 template │ │ │ │ │ -_2_6_2 static constexpr bool hasStaticDegree = Std::is_detected::value; │ │ │ │ │ -263 │ │ │ │ │ -264 // accessor mixins need to be friends for access to proxiedNode() │ │ │ │ │ -265 friend class _S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s; │ │ │ │ │ -266 friend class _D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s; │ │ │ │ │ -267 │ │ │ │ │ -268 public: │ │ │ │ │ -269 │ │ │ │ │ -_2_7_0 typedef Node _P_r_o_x_i_e_d_N_o_d_e; │ │ │ │ │ -271 │ │ │ │ │ -_2_7_2 typedef _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_N_o_d_e_T_a_g_<_N_o_d_e_> _N_o_d_e_T_a_g; │ │ │ │ │ -273 │ │ │ │ │ -_2_7_5 static const bool _i_s_L_e_a_f = Node::isLeaf; │ │ │ │ │ +227 │ │ │ │ │ +228#ifndef DOXYGEN │ │ │ │ │ +229 │ │ │ │ │ +230 namespace impl { │ │ │ │ │ +231 │ │ │ │ │ +232 template │ │ │ │ │ +233 struct _ChildForTreePath │ │ │ │ │ +234 { │ │ │ │ │ +235 using type = typename std::decay(),std:: │ │ │ │ │ +declval()))>::type; │ │ │ │ │ +236 }; │ │ │ │ │ +237 │ │ │ │ │ +238 } │ │ │ │ │ +239 │ │ │ │ │ +240#endif // DOXYGEN │ │ │ │ │ +241 │ │ │ │ │ +243 │ │ │ │ │ +251 template │ │ │ │ │ +_2_5_2 using _C_h_i_l_d_F_o_r_T_r_e_e_P_a_t_h = typename impl::_ChildForTreePath:: │ │ │ │ │ +type; │ │ │ │ │ +253 │ │ │ │ │ +254 │ │ │ │ │ +255#ifndef DOXYGEN │ │ │ │ │ +256 │ │ │ │ │ +257 namespace impl { │ │ │ │ │ +258 │ │ │ │ │ +259 // By default, types are flat indices if they are integral │ │ │ │ │ +260 template │ │ │ │ │ +261 struct _is_flat_index │ │ │ │ │ +262 { │ │ │ │ │ +263 using type = std::is_integral; │ │ │ │ │ +264 }; │ │ │ │ │ +265 │ │ │ │ │ +266 // And so is any index_constant │ │ │ │ │ +267 template │ │ │ │ │ +268 struct _is_flat_index> │ │ │ │ │ +269 { │ │ │ │ │ +270 using type = std::true_type; │ │ │ │ │ +271 }; │ │ │ │ │ +272 │ │ │ │ │ +273 } │ │ │ │ │ +274 │ │ │ │ │ +275#endif // DOXYGEN │ │ │ │ │ 276 │ │ │ │ │ -_2_7_8 static const bool _i_s_P_o_w_e_r = Node::isPower; │ │ │ │ │ -279 │ │ │ │ │ -_2_8_1 static const bool _i_s_C_o_m_p_o_s_i_t_e = Node::isComposite; │ │ │ │ │ -282 │ │ │ │ │ -283 template , int> = 0> │ │ │ │ │ -_2_8_5 static constexpr auto _d_e_g_r_e_e () │ │ │ │ │ -286 { │ │ │ │ │ -287 return N::degree(); │ │ │ │ │ -288 } │ │ │ │ │ +278 /* │ │ │ │ │ +279 * This type trait can be used to check whether T is a flat index (i.e. │ │ │ │ │ +either `std::size_t` │ │ │ │ │ +280 * or `index_constant`). The type trait normalizes T before doing the check, │ │ │ │ │ +so it will also │ │ │ │ │ +281 * work correctly for references and cv-qualified types. │ │ │ │ │ +282 */ │ │ │ │ │ +283 template │ │ │ │ │ +_2_8_4 using _i_s___f_l_a_t___i_n_d_e_x = typename impl::_is_flat_index>::type; │ │ │ │ │ +285 │ │ │ │ │ +286#ifndef DOXYGEN │ │ │ │ │ +287 │ │ │ │ │ +288 namespace impl { │ │ │ │ │ 289 │ │ │ │ │ -290 template , int> = 0> │ │ │ │ │ -_2_9_2 auto _d_e_g_r_e_e () const │ │ │ │ │ -293 { │ │ │ │ │ -294 return _p_r_o_x_i_e_d_N_o_d_e().degree(); │ │ │ │ │ -295 } │ │ │ │ │ -296 │ │ │ │ │ -297 │ │ │ │ │ -298 protected: │ │ │ │ │ -299 │ │ │ │ │ +290 // helper function for check in member child() functions that tolerates │ │ │ │ │ +being passed something that │ │ │ │ │ +291 // isn't a TreePath. It will just return 0 in that case │ │ │ │ │ +292 │ │ │ │ │ +293 template │ │ │ │ │ +294 constexpr typename std::enable_if< │ │ │ │ │ +295 _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_s___f_l_a_t___i_n_d_e_x_<_T_>_:_:_v_a_l_u_e, │ │ │ │ │ +296 bool │ │ │ │ │ +297 >::type │ │ │ │ │ +298 _non_empty_tree_path (T) │ │ │ │ │ +299 { │ │ │ │ │ +300 return false; │ │ │ │ │ +301 } │ │ │ │ │ 302 │ │ │ │ │ -304 template │ │ │ │ │ -305 typename std::enable_if::type │ │ │ │ │ -_3_0_6 _p_r_o_x_i_e_d_N_o_d_e () │ │ │ │ │ -307 { │ │ │ │ │ -308 return *_node; │ │ │ │ │ -309 } │ │ │ │ │ -310 │ │ │ │ │ -_3_1_2 const Node& _p_r_o_x_i_e_d_N_o_d_e () const │ │ │ │ │ -313 { │ │ │ │ │ -314 return *_node; │ │ │ │ │ -315 } │ │ │ │ │ +303 template │ │ │ │ │ +304 constexpr typename std::enable_if< │ │ │ │ │ +305 !_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_s___f_l_a_t___i_n_d_e_x_<_T_>_:_:_v_a_l_u_e, │ │ │ │ │ +306 bool │ │ │ │ │ +307 >::type │ │ │ │ │ +308 _non_empty_tree_path (T t) │ │ │ │ │ +309 { │ │ │ │ │ +310 return _t_r_e_e_P_a_t_h_S_i_z_e(t) > 0; │ │ │ │ │ +311 } │ │ │ │ │ +312 │ │ │ │ │ +313 } │ │ │ │ │ +314 │ │ │ │ │ +315#endif // DOXYGEN │ │ │ │ │ 316 │ │ │ │ │ -318 template │ │ │ │ │ -319 typename std::enable_if >::type │ │ │ │ │ -_3_2_0 _p_r_o_x_i_e_d_N_o_d_e_S_t_o_r_a_g_e () │ │ │ │ │ -321 { │ │ │ │ │ -322 return _node; │ │ │ │ │ -323 } │ │ │ │ │ -324 │ │ │ │ │ -_3_2_6 std::shared_ptr _p_r_o_x_i_e_d_N_o_d_e_S_t_o_r_a_g_e () const │ │ │ │ │ -327 { │ │ │ │ │ -328 return _node; │ │ │ │ │ -329 } │ │ │ │ │ -330 │ │ │ │ │ -332 │ │ │ │ │ -335 │ │ │ │ │ -_3_3_6 _P_r_o_x_y_N_o_d_e (Node& node) │ │ │ │ │ -337 : _node(stackobject_to_shared_ptr(node)) │ │ │ │ │ -338 {} │ │ │ │ │ -339 │ │ │ │ │ -_3_4_0 _P_r_o_x_y_N_o_d_e (std::shared_ptr node) │ │ │ │ │ -341 : _node(std::move(node)) │ │ │ │ │ -342 {} │ │ │ │ │ -343 │ │ │ │ │ -345 │ │ │ │ │ -346 private: │ │ │ │ │ -347 │ │ │ │ │ -348 std::shared_ptr _node; │ │ │ │ │ -349 }; │ │ │ │ │ -350 │ │ │ │ │ -352 │ │ │ │ │ -353 } // namespace TypeTree │ │ │ │ │ -354} //namespace Dune │ │ │ │ │ -355 │ │ │ │ │ -356#endif // DUNE_TYPETREE_PROXYNODE_HH │ │ │ │ │ +318 │ │ │ │ │ +319 } // namespace TypeTree │ │ │ │ │ +320} //namespace Dune │ │ │ │ │ +321 │ │ │ │ │ +322#endif // DUNE_TYPETREE_CHILDEXTRACTION_HH │ │ │ │ │ _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 │ │ │ │ │ -_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 │ │ │ │ │ +_t_r_e_e_p_a_t_h_._h_h │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_s___f_l_a_t___i_n_d_e_x │ │ │ │ │ +typename impl::_is_flat_index< std::decay_t< T > >::type is_flat_index │ │ │ │ │ +Type trait that determines whether T is a flat index in the context of child │ │ │ │ │ +extraction. │ │ │ │ │ +DDeeffiinniittiioonn childextraction.hh:284 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ +ImplementationDefined childStorage(Node &&node, Indices... indices) │ │ │ │ │ +DDeeffiinniittiioonn childextraction.hh:138 │ │ │ │ │ +_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_:_:_C_h_i_l_d_F_o_r_T_r_e_e_P_a_t_h │ │ │ │ │ +typename impl::_ChildForTreePath< Node, TreePath >::type ChildForTreePath │ │ │ │ │ +Template alias for the type of a child node given by a TreePath or a │ │ │ │ │ +HybridTreePath type. │ │ │ │ │ +DDeeffiinniittiioonn childextraction.hh:252 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_t_r_e_e_P_a_t_h_S_i_z_e │ │ │ │ │ +constexpr std::size_t treePathSize(const HybridTreePath< T... > &) │ │ │ │ │ +Returns the size (number of components) of the given HybridTreePath. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:334 │ │ │ │ │ +_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_:_:_L_e_a_f_N_o_d_e_T_a_g │ │ │ │ │ -Tag designating a leaf node. │ │ │ │ │ -DDeeffiinniittiioonn nodetags.hh:18 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_T_a_g │ │ │ │ │ -Tag designating a power node. │ │ │ │ │ -DDeeffiinniittiioonn nodetags.hh:21 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g │ │ │ │ │ -Tag designating a power node with runtime degree. │ │ │ │ │ -DDeeffiinniittiioonn nodetags.hh:24 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g │ │ │ │ │ -Tag designating a composite node. │ │ │ │ │ -DDeeffiinniittiioonn nodetags.hh:27 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e │ │ │ │ │ -Base class for nodes acting as a proxy for an existing node. │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:255 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_P_r_o_x_y_N_o_d_e │ │ │ │ │ -ProxyNode(Node &node) │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:336 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_N_o_d_e_T_a_g │ │ │ │ │ -Dune::TypeTree::NodeTag< Node > NodeTag │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:272 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_i_s_C_o_m_p_o_s_i_t_e │ │ │ │ │ -static const bool isComposite │ │ │ │ │ -Mark this class as a composite in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:281 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_i_s_L_e_a_f │ │ │ │ │ -static const bool isLeaf │ │ │ │ │ -Mark this class as non leaf in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:275 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_i_s_P_o_w_e_r │ │ │ │ │ -static const bool isPower │ │ │ │ │ -Mark this class as a non power in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:278 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_d_e_g_r_e_e │ │ │ │ │ -auto degree() const │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:292 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_p_r_o_x_i_e_d_N_o_d_e │ │ │ │ │ -std::enable_if< enabled, Node & >::type proxiedNode() │ │ │ │ │ -Returns the proxied node. │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:306 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_p_r_o_x_i_e_d_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ -std::shared_ptr< const Node > proxiedNodeStorage() const │ │ │ │ │ -Returns the storage of the proxied node (const version). │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:326 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_P_r_o_x_i_e_d_N_o_d_e │ │ │ │ │ -Node ProxiedNode │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:270 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_p_r_o_x_i_e_d_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ -std::enable_if< enabled, std::shared_ptr< Node > >::type proxiedNodeStorage() │ │ │ │ │ -Returns the storage of the proxied node. │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:320 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_d_e_g_r_e_e │ │ │ │ │ -static constexpr auto degree() │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:285 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_P_r_o_x_y_N_o_d_e │ │ │ │ │ -ProxyNode(std::shared_ptr< Node > node) │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:340 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_p_r_o_x_i_e_d_N_o_d_e │ │ │ │ │ -const Node & proxiedNode() const │ │ │ │ │ -Returns the proxied node (const version). │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:312 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s │ │ │ │ │ -Mixin class providing methods for child access with compile-time parameter. │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:30 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_c_h_i_l_d │ │ │ │ │ -auto & child(index_constant< k >={}) │ │ │ │ │ -Returns the i-th child. │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:71 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ -void setChild(ProxyChild &&child, typename std::enable_if< lazy_enabled< k >:: │ │ │ │ │ -value, void * >::type=0) │ │ │ │ │ -Sets the i-th child to the passed-in value. │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:112 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_n_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ -const ProxiedNode::NodeStorage & nodeStorage() const │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:117 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ -auto childStorage(index_constant< k >={}) │ │ │ │ │ -Returns the storage of the i-th child. │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:92 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_c_h_i_l_d │ │ │ │ │ -const auto & child(index_constant< k >={}) const │ │ │ │ │ -Returns the i-th child (const version). │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:81 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ -auto childStorage(index_constant< k >={}) const │ │ │ │ │ -Returns the storage of the i-th child (const version). │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:105 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_C_h_i_l_d │ │ │ │ │ -Access to the type and storage type of the i-th child. │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:60 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s │ │ │ │ │ -Mixin class providing methods for child access with run-time parameter. │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:133 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_c_h_i_l_d │ │ │ │ │ -auto & child(std::size_t i) │ │ │ │ │ -Returns the i-th child. │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:162 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ -auto childStorage(std::size_t i) const │ │ │ │ │ -Returns the storage of the i-th child (const version). │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:194 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ -void setChild(std::size_t i, ProxyChild &&child, typename std::enable_if< │ │ │ │ │ -enabled, void * >::type=0) │ │ │ │ │ -Sets the i-th child to the passed-in value. │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:201 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_c_h_i_l_d │ │ │ │ │ -const auto & child(std::size_t i) const │ │ │ │ │ -Returns the i-th child (const version). │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:171 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ -auto childStorage(std::size_t i) │ │ │ │ │ -Returns the storage of the i-th child. │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:182 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e │ │ │ │ │ -Tag-based dispatch to appropriate base class that provides necessary │ │ │ │ │ -functionality. │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:210 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g_ _>_:_:_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ -Node::NodeStorage NodeStorage │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:224 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g_ _>_:_:_C_h_i_l_d_T_y_p_e_s │ │ │ │ │ -Node::ChildTypes ChildTypes │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:223 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _P_o_w_e_r_N_o_d_e_T_a_g_ _>_:_:_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ -Node::NodeStorage NodeStorage │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:233 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _P_o_w_e_r_N_o_d_e_T_a_g_ _>_:_:_C_h_i_l_d_T_y_p_e │ │ │ │ │ -Node::ChildType ChildType │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:232 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g_ _>_:_:_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ -Node::NodeStorage NodeStorage │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:242 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g_ _>_:_:_C_h_i_l_d_T_y_p_e │ │ │ │ │ -Node::ChildType ChildType │ │ │ │ │ -DDeeffiinniittiioonn proxynode.hh:241 │ │ │ │ │ +_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 │ │ │ │ │ =============================================================================== │ │ │ │ │ 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: visitor.hh File Reference │ │ │ │ +dune-typetree: powernode.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -71,109 +71,46 @@ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │
│ │ │ │
│ │ │ │ Classes | │ │ │ │ -Namespaces | │ │ │ │ -Functions | │ │ │ │ -Variables
│ │ │ │ -
visitor.hh File Reference
│ │ │ │ +Namespaces
│ │ │ │ +
powernode.hh File Reference
│ │ │ │ │ │ │ │
│ │ │ │ -
#include <dune/typetree/treepath.hh>
│ │ │ │ -#include <dune/common/hybridutilities.hh>
│ │ │ │ +
#include <cassert>
│ │ │ │ +#include <array>
│ │ │ │ +#include <memory>
│ │ │ │ +#include <type_traits>
│ │ │ │ +#include <dune/common/typetraits.hh>
│ │ │ │ +#include <dune/common/std/type_traits.hh>
│ │ │ │ +#include <dune/typetree/nodetags.hh>
│ │ │ │ +#include <dune/typetree/utility.hh>
│ │ │ │ +#include <dune/typetree/childextraction.hh>
│ │ │ │ +#include <dune/typetree/typetraits.hh>
│ │ │ │
│ │ │ │

Go to the source code of this file.

│ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │

│ │ │ │ Classes

struct  Dune::TypeTree::DefaultVisitor
 Visitor interface and base class for TypeTree visitors. More...
class  Dune::TypeTree::PowerNode< T, k >
 Collect k instances of type T within a dune-typetree. More...
 
struct  Dune::TypeTree::DefaultPairVisitor
 Visitor interface and base class for visitors of pairs of TypeTrees. More...
 
struct  Dune::TypeTree::Experimental::DefaultHybridVisitor
 Hybrid visitor interface and base class for TypeTree hybrid visitors. More...
 
struct  Dune::TypeTree::VisitDirectChildren
 Mixin base class for visitors that only want to visit the direct children of a node. More...
 
struct  Dune::TypeTree::VisitDirectChildren::VisitChild< Node1, Child1, Node2, Child2, TreePath >
 Template struct for determining whether or not to visit a given child. More...
 
struct  Dune::TypeTree::VisitTree
 Mixin base class for visitors that want to visit the complete tree. More...
 
struct  Dune::TypeTree::VisitTree::VisitChild< Node1, Child1, Node2, Child2, TreePath >
 Template struct for determining whether or not to visit a given child. More...
 
struct  Dune::TypeTree::StaticTraversal
 Mixin base class for visitors that require a static TreePath during traversal. More...
 
struct  Dune::TypeTree::DynamicTraversal
 Mixin base class for visitors that only need a dynamic TreePath during traversal. More...
 
struct  Dune::TypeTree::TreeVisitor
 Convenience base class for visiting the entire tree. More...
 
struct  Dune::TypeTree::DirectChildrenVisitor
 Convenience base class for visiting the direct children of a node. More...
 
struct  Dune::TypeTree::TreePairVisitor
 Convenience base class for visiting an entire tree pair. More...
 
struct  Dune::TypeTree::DirectChildrenPairVisitor
 Convenience base class for visiting the direct children of a node pair. More...
 
struct  Dune::TypeTree::Experimental::Info::LeafCounterVisitor
 
struct  Dune::TypeTree::Experimental::Info::NodeCounterVisitor
 
struct  Dune::TypeTree::Experimental::Info::DepthVisitor
struct  Dune::TypeTree::PowerNode< T, k >::Child< i >
 Access to the type and storage type of the i-th child. More...
 
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -

│ │ │ │ Namespaces

namespace  Dune
 
namespace  Dune::TypeTree
 
namespace  Dune::TypeTree::Experimental
 
namespace  Dune::TypeTree::Experimental::Info
 
│ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -

│ │ │ │ -Functions

template<typename Tree >
auto Dune::TypeTree::Experimental::Info::depth (const Tree &tree)
 The depth of the TypeTree.
 
template<typename Tree >
constexpr auto Dune::TypeTree::Experimental::Info::depth ()
 The depth of the Tree.
 
template<typename Tree >
auto Dune::TypeTree::Experimental::Info::nodeCount (const Tree &tree)
 The total number of nodes in the Tree.
 
template<typename Tree >
auto Dune::TypeTree::Experimental::Info::leafCount (const Tree &tree)
 The number of leaf nodes in the Tree.
 
│ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │

│ │ │ │ -Variables

template<typename Tree >
constexpr bool Dune::TypeTree::Experimental::Info::isDynamic = std::is_same<std::size_t, decltype(leafCount(std::declval<Tree>()))>{}
 true if any of the nodes in the tree only has dynamic degree.
 
│ │ │ │
│ │ │ │ │ │ │ │
│ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
│ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,106 +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 | _V_a_r_i_a_b_l_e_s │ │ │ │ │ -visitor.hh File Reference │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_e_e_p_a_t_h_._h_h> │ │ │ │ │ -#include │ │ │ │ │ +_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s │ │ │ │ │ +powernode.hh File Reference │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#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_/_u_t_i_l_i_t_y_._h_h> │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h> │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_y_p_e_t_r_a_i_t_s_._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_:_:_D_e_f_a_u_l_t_V_i_s_i_t_o_r │ │ │ │ │ -  Visitor interface and base class for _T_y_p_e_T_r_e_e visitors. _M_o_r_e_._._. │ │ │ │ │ + class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_<_ _T_,_ _k_ _> │ │ │ │ │ +  Collect k instances of type T within a _d_u_n_e_-_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_:_:_D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ -  Visitor interface and base class for visitors of pairs of TypeTrees. │ │ │ │ │ - _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r │ │ │ │ │ -  Hybrid visitor interface and base class for _T_y_p_e_T_r_e_e hybrid visitors. │ │ │ │ │ - _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_D_i_r_e_c_t_C_h_i_l_d_r_e_n │ │ │ │ │ -  Mixin base class for visitors that only want to visit the direct │ │ │ │ │ - children of a node. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_D_i_r_e_c_t_C_h_i_l_d_r_e_n_:_:_V_i_s_i_t_C_h_i_l_d_<_ _N_o_d_e_1_,_ _C_h_i_l_d_1_,_ _N_o_d_e_2_, │ │ │ │ │ - _C_h_i_l_d_2_,_ _T_r_e_e_P_a_t_h_ _> │ │ │ │ │ -  Template struct for determining whether or not to visit a given child. │ │ │ │ │ - _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_T_r_e_e │ │ │ │ │ -  Mixin base class for visitors that want to visit the complete tree. │ │ │ │ │ - _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_T_r_e_e_:_:_V_i_s_i_t_C_h_i_l_d_<_ _N_o_d_e_1_,_ _C_h_i_l_d_1_,_ _N_o_d_e_2_,_ _C_h_i_l_d_2_, │ │ │ │ │ - _T_r_e_e_P_a_t_h_ _> │ │ │ │ │ -  Template struct for determining whether or not to visit a given child. │ │ │ │ │ - _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_T_r_a_v_e_r_s_a_l │ │ │ │ │ -  Mixin base class for visitors that require a static TreePath during │ │ │ │ │ - traversal. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_T_r_a_v_e_r_s_a_l │ │ │ │ │ -  Mixin base class for visitors that only need a dynamic TreePath during │ │ │ │ │ - traversal. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_V_i_s_i_t_o_r │ │ │ │ │ -  Convenience base class for visiting the entire tree. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_i_r_e_c_t_C_h_i_l_d_r_e_n_V_i_s_i_t_o_r │ │ │ │ │ -  Convenience base class for visiting the direct children of a node. │ │ │ │ │ - _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ -  Convenience base class for visiting an entire tree pair. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_i_r_e_c_t_C_h_i_l_d_r_e_n_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ -  Convenience base class for visiting the direct children of a node │ │ │ │ │ - pair. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_L_e_a_f_C_o_u_n_t_e_r_V_i_s_i_t_o_r │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_N_o_d_e_C_o_u_n_t_e_r_V_i_s_i_t_o_r │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_D_e_p_t_h_V_i_s_i_t_o_r │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_<_ _T_,_ _k_ _>_:_:_C_h_i_l_d_<_ _i_ _> │ │ │ │ │ +  Access to the type and storage type of the i-th child. _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 │ │ │ │ │ -  │ │ │ │ │ -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_:_:_I_n_f_o │ │ │ │ │ -  │ │ │ │ │ -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_:_:_I_n_f_o_:_:_d_e_p_t_h (const Tree &tree) │ │ │ │ │ -  The depth of the _T_y_p_e_T_r_e_e. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ -constexpr 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_:_:_I_n_f_o_:_:_d_e_p_t_h () │ │ │ │ │ -  The depth of the Tree. │ │ │ │ │ -  │ │ │ │ │ -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_:_:_I_n_f_o_:_:_n_o_d_e_C_o_u_n_t (const Tree │ │ │ │ │ - &tree) │ │ │ │ │ -  The total number of nodes in the Tree. │ │ │ │ │ -  │ │ │ │ │ -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_:_:_I_n_f_o_:_:_l_e_a_f_C_o_u_n_t (const Tree │ │ │ │ │ - &tree) │ │ │ │ │ -  The number of leaf nodes in the Tree. │ │ │ │ │ -  │ │ │ │ │ -VVaarriiaabblleess │ │ │ │ │ -template │ │ │ │ │ -constexpr bool  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_i_s_D_y_n_a_m_i_c = std:: │ │ │ │ │ - is_same()))> │ │ │ │ │ - {} │ │ │ │ │ -  true if any of the nodes in the tree only has dynamic degree. │ │ │ │ │ -  │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00011_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: visitor.hh Source File │ │ │ │ +dune-typetree: powernode.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,385 +74,401 @@ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ │
│ │ │ │ -
visitor.hh
│ │ │ │ +
powernode.hh
│ │ │ │
│ │ │ │
│ │ │ │ Go to the documentation of this file.
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_VISITOR_HH
│ │ │ │ -
7#define DUNE_TYPETREE_VISITOR_HH
│ │ │ │ +
6#ifndef DUNE_TYPETREE_POWERNODE_HH
│ │ │ │ +
7#define DUNE_TYPETREE_POWERNODE_HH
│ │ │ │
8
│ │ │ │ -
9#include <dune/typetree/treepath.hh>
│ │ │ │ -
10#include <dune/common/hybridutilities.hh>
│ │ │ │ -
11
│ │ │ │ -
12namespace Dune {
│ │ │ │ -
13 namespace TypeTree {
│ │ │ │ -
14
│ │ │ │ +
9#include <cassert>
│ │ │ │ +
10#include <array>
│ │ │ │ +
11#include <memory>
│ │ │ │ +
12#include <type_traits>
│ │ │ │ +
13
│ │ │ │ +
14#include <dune/common/typetraits.hh>
│ │ │ │ +
15#include <dune/common/std/type_traits.hh>
│ │ │ │ +
16
│ │ │ │ +
17#include <dune/typetree/nodetags.hh>
│ │ │ │ +
18#include <dune/typetree/utility.hh>
│ │ │ │ +
19#include <dune/typetree/childextraction.hh>
│ │ │ │ +
20#include <dune/typetree/typetraits.hh>
│ │ │ │
21
│ │ │ │ -
│ │ │ │ -
48 struct DefaultVisitor
│ │ │ │ -
49 {
│ │ │ │ -
50
│ │ │ │ -
52
│ │ │ │ -
59 template<typename T, typename TreePath>
│ │ │ │ -
60 void pre(T&&, TreePath) const {}
│ │ │ │ +
22namespace Dune {
│ │ │ │ +
23 namespace TypeTree {
│ │ │ │ +
24
│ │ │ │ +
31#ifndef DOXYGEN
│ │ │ │ +
32
│ │ │ │ +
34 template<typename PowerNode, typename T, std::size_t k>
│ │ │ │ +
35 struct AssertPowerNodeChildCount
│ │ │ │ +
36 : public std::enable_if<std::is_same<
│ │ │ │ +
37 typename PowerNode::ChildType,
│ │ │ │ +
38 T>::value &&
│ │ │ │ +
39 PowerNode::degree() == k,
│ │ │ │ +
40 T>
│ │ │ │ +
41 {};
│ │ │ │ +
42
│ │ │ │ +
43#endif
│ │ │ │ +
44
│ │ │ │ +
50 template<typename T, std::size_t k>
│ │ │ │ +
│ │ │ │ +
51 class PowerNode
│ │ │ │ +
52 {
│ │ │ │ +
53
│ │ │ │ +
54 public:
│ │ │ │ +
55
│ │ │ │ +
57 static const bool isLeaf = false;
│ │ │ │ +
58
│ │ │ │ +
60 static const bool isPower = true;
│ │ │ │
61
│ │ │ │ -
63
│ │ │ │ -
71 template<typename T, typename TreePath>
│ │ │ │ -
72 void in(T&&, TreePath) const {}
│ │ │ │ -
73
│ │ │ │ +
63 static const bool isComposite = false;
│ │ │ │ +
64
│ │ │ │ +
│ │ │ │ +
65 static constexpr auto degree ()
│ │ │ │ +
66 {
│ │ │ │ +
67 return std::integral_constant<std::size_t,k>{};
│ │ │ │ +
68 }
│ │ │ │ +
│ │ │ │ +
69
│ │ │ │ +
71 typedef PowerNodeTag NodeTag;
│ │ │ │ +
72
│ │ │ │ +
74 typedef T ChildType;
│ │ │ │
75
│ │ │ │ -
82 template<typename T, typename TreePath>
│ │ │ │ -
83 void post(T&&, TreePath) const {}
│ │ │ │ +
77 typedef std::array<std::shared_ptr<T>,k> NodeStorage;
│ │ │ │ +
78
│ │ │ │ +
79
│ │ │ │ +
81 template<std::size_t i>
│ │ │ │ +
│ │ │ │ +
82 struct Child
│ │ │ │ +
83 {
│ │ │ │
84
│ │ │ │ +
85 static_assert((i < degree()), "child index out of range");
│ │ │ │
86
│ │ │ │ -
92 template<typename T, typename TreePath>
│ │ │ │ -
93 void leaf(T&&, TreePath) const {}
│ │ │ │ -
94
│ │ │ │ +
88 typedef T Type;
│ │ │ │ +
89
│ │ │ │ +
91 typedef T type;
│ │ │ │ +
92 };
│ │ │ │ +
│ │ │ │ +
93
│ │ │ │
96
│ │ │ │ -
106 template<typename T, typename Child, typename TreePath, typename ChildIndex>
│ │ │ │ -
107 void beforeChild(T&&, Child&&, TreePath, ChildIndex) const {}
│ │ │ │ -
108
│ │ │ │ -
110
│ │ │ │ -
121 template<typename T, typename Child, typename TreePath, typename ChildIndex>
│ │ │ │ -
122 void afterChild(T&&, Child&&, TreePath, ChildIndex) const {}
│ │ │ │ -
123
│ │ │ │ -
124 };
│ │ │ │ -
│ │ │ │ -
125
│ │ │ │ -
126
│ │ │ │ -
128
│ │ │ │ -
│ │ │ │ -
163 struct DefaultPairVisitor
│ │ │ │ -
164 {
│ │ │ │ -
165
│ │ │ │ +
98
│ │ │ │ +
101 template<std::size_t i>
│ │ │ │ +
│ │ │ │ +
102 T& child (index_constant<i> = {})
│ │ │ │ +
103 {
│ │ │ │ +
104 static_assert((i < degree()), "child index out of range");
│ │ │ │ +
105 return *_children[i];
│ │ │ │ +
106 }
│ │ │ │ +
│ │ │ │ +
107
│ │ │ │ +
109
│ │ │ │ +
112 template<std::size_t i>
│ │ │ │ +
│ │ │ │ +
113 const T& child (index_constant<i> = {}) const
│ │ │ │ +
114 {
│ │ │ │ +
115 static_assert((i < degree()), "child index out of range");
│ │ │ │ +
116 return *_children[i];
│ │ │ │ +
117 }
│ │ │ │ +
│ │ │ │ +
118
│ │ │ │ +
120
│ │ │ │ +
123 template<std::size_t i>
│ │ │ │ +
│ │ │ │ +
124 std::shared_ptr<T> childStorage (index_constant<i> = {})
│ │ │ │ +
125 {
│ │ │ │ +
126 static_assert((i < degree()), "child index out of range");
│ │ │ │ +
127 return _children[i];
│ │ │ │ +
128 }
│ │ │ │ +
│ │ │ │ +
129
│ │ │ │ +
131
│ │ │ │ +
134 template<std::size_t i>
│ │ │ │ +
│ │ │ │ +
135 std::shared_ptr<const T> childStorage (index_constant<i> = {}) const
│ │ │ │ +
136 {
│ │ │ │ +
137 static_assert((i < degree()), "child index out of range");
│ │ │ │ +
138 return _children[i];
│ │ │ │ +
139 }
│ │ │ │ +
│ │ │ │ +
140
│ │ │ │ +
142 template<std::size_t i>
│ │ │ │ +
│ │ │ │ +
143 void setChild (T& t, index_constant<i> = {})
│ │ │ │ +
144 {
│ │ │ │ +
145 static_assert((i < degree()), "child index out of range");
│ │ │ │ +
146 _children[i] = stackobject_to_shared_ptr(t);
│ │ │ │ +
147 }
│ │ │ │ +
│ │ │ │ +
148
│ │ │ │ +
150 template<std::size_t i>
│ │ │ │ +
│ │ │ │ +
151 void setChild (T&& t, index_constant<i> = {})
│ │ │ │ +
152 {
│ │ │ │ +
153 static_assert((i < degree()), "child index out of range");
│ │ │ │ +
154 _children[i] = convert_arg(std::move(t));
│ │ │ │ +
155 }
│ │ │ │ +
│ │ │ │ +
156
│ │ │ │ +
158 template<std::size_t i>
│ │ │ │ +
│ │ │ │ +
159 void setChild (std::shared_ptr<T> st, index_constant<i> = {})
│ │ │ │ +
160 {
│ │ │ │ +
161 static_assert((i < degree()), "child index out of range");
│ │ │ │ +
162 _children[i] = std::move(st);
│ │ │ │ +
163 }
│ │ │ │ +
│ │ │ │ +
164
│ │ │ │ +
166
│ │ │ │
167
│ │ │ │ -
175 template<typename T1, typename T2, typename TreePath>
│ │ │ │ -
176 void pre(T1&&, T2&&, TreePath) const {}
│ │ │ │ -
177
│ │ │ │ -
179
│ │ │ │ -
188 template<typename T1, typename T2, typename TreePath>
│ │ │ │ -
189 void in(T1&&, T2&&, TreePath) const {}
│ │ │ │ +
170
│ │ │ │ +
172
│ │ │ │ +
│ │ │ │ +
175 T& child (std::size_t i)
│ │ │ │ +
176 {
│ │ │ │ +
177 assert(i < degree() && "child index out of range");
│ │ │ │ +
178 return *_children[i];
│ │ │ │ +
179 }
│ │ │ │ +
│ │ │ │ +
180
│ │ │ │ +
182
│ │ │ │ +
│ │ │ │ +
185 const T& child (std::size_t i) const
│ │ │ │ +
186 {
│ │ │ │ +
187 assert(i < degree() && "child index out of range");
│ │ │ │ +
188 return *_children[i];
│ │ │ │ +
189 }
│ │ │ │ +
│ │ │ │
190
│ │ │ │
192
│ │ │ │ -
200 template<typename T1, typename T2, typename TreePath>
│ │ │ │ -
201 void post(T1&&, T2&&, TreePath) const {}
│ │ │ │ +
│ │ │ │ +
195 std::shared_ptr<T> childStorage (std::size_t i)
│ │ │ │ +
196 {
│ │ │ │ +
197 assert(i < degree() && "child index out of range");
│ │ │ │ +
198 return _children[i];
│ │ │ │ +
199 }
│ │ │ │ +
│ │ │ │ +
200
│ │ │ │
202
│ │ │ │ -
204
│ │ │ │ -
215 template<typename T1, typename T2, typename TreePath>
│ │ │ │ -
216 void leaf(T1&&, T2&&, TreePath) const {}
│ │ │ │ +
│ │ │ │ +
205 std::shared_ptr<const T> childStorage (std::size_t i) const
│ │ │ │ +
206 {
│ │ │ │ +
207 assert(i < degree() && "child index out of range");
│ │ │ │ +
208 return _children[i];
│ │ │ │ +
209 }
│ │ │ │ +
│ │ │ │ +
210
│ │ │ │ +
│ │ │ │ +
212 void setChild (std::size_t i, T& t)
│ │ │ │ +
213 {
│ │ │ │ +
214 assert(i < degree() && "child index out of range");
│ │ │ │ +
215 _children[i] = stackobject_to_shared_ptr(t);
│ │ │ │ +
216 }
│ │ │ │ +
│ │ │ │
217
│ │ │ │ -
219
│ │ │ │ -
231 template<typename T1, typename Child1, typename T2, typename Child2, typename TreePath, typename ChildIndex>
│ │ │ │ -
232 void beforeChild(T1&&, Child1&&, T2&&, Child2&&, TreePath, ChildIndex) const {}
│ │ │ │ -
233
│ │ │ │ -
235
│ │ │ │ -
247 template<typename T1, typename Child1, typename T2, typename Child2, typename TreePath, typename ChildIndex>
│ │ │ │ -
248 void afterChild(T1&&, Child1&&, T2&&, Child2&&, TreePath, ChildIndex) const {}
│ │ │ │ -
249
│ │ │ │ -
250 };
│ │ │ │ -
│ │ │ │ -
251
│ │ │ │ -
252
│ │ │ │ -
253 namespace Experimental {
│ │ │ │ -
254
│ │ │ │ -
│ │ │ │ -
285 struct DefaultHybridVisitor
│ │ │ │ -
286 {
│ │ │ │ -
287
│ │ │ │ -
295 template<typename T, typename TreePath, typename U>
│ │ │ │ -
296 auto pre(T&&, TreePath, const U& u) const { return u;}
│ │ │ │ -
297
│ │ │ │ -
305 template<typename T, typename TreePath, typename U>
│ │ │ │ -
306 auto in(T&&, TreePath, const U& u) const {return u;}
│ │ │ │ +
│ │ │ │ +
219 void setChild (std::size_t i, T&& t)
│ │ │ │ +
220 {
│ │ │ │ +
221 assert(i < degree() && "child index out of range");
│ │ │ │ +
222 _children[i] = convert_arg(std::move(t));
│ │ │ │ +
223 }
│ │ │ │ +
│ │ │ │ +
224
│ │ │ │ +
│ │ │ │ +
226 void setChild (std::size_t i, std::shared_ptr<T> st)
│ │ │ │ +
227 {
│ │ │ │ +
228 assert(i < degree() && "child index out of range");
│ │ │ │ +
229 _children[i] = std::move(st);
│ │ │ │ +
230 }
│ │ │ │ +
│ │ │ │ +
231
│ │ │ │ +
│ │ │ │ +
232 const NodeStorage& nodeStorage () const
│ │ │ │ +
233 {
│ │ │ │ +
234 return _children;
│ │ │ │ +
235 }
│ │ │ │ +
│ │ │ │ +
236
│ │ │ │ +
238
│ │ │ │ +
241
│ │ │ │ +
242 // The following two methods require a little bit of SFINAE trickery to work correctly:
│ │ │ │ +
243 // We have to make sure that they don't shadow the methods for direct child access because
│ │ │ │ +
244 // those get called by the generic child() machinery. If that machinery picks up the methods
│ │ │ │ +
245 // defined below, we have an infinite recursion.
│ │ │ │ +
246 // So the methods make sure that either
│ │ │ │ +
247 //
│ │ │ │ +
248 // * there are more than one argument. In that case, we got multiple indices and can forward
│ │ │ │ +
249 // to the general machine.
│ │ │ │ +
250 //
│ │ │ │ +
251 // * the first argument is not a valid flat index, i.e. either a std::size_t or an index_constant.
│ │ │ │ +
252 // The argument thus has to be some kind of TreePath instance that we can also pass to the
│ │ │ │ +
253 // generic machine.
│ │ │ │ +
254 //
│ │ │ │ +
255 // The above SFINAE logic works, but there is still a problem with the return type deduction.
│ │ │ │ +
256 // We have to do a lazy lookup of the return type after SFINAE has succeeded, otherwise the return
│ │ │ │ +
257 // type deduction will trigger the infinite recursion.
│ │ │ │ +
258
│ │ │ │ +
260
│ │ │ │ +
264#ifdef DOXYGEN
│ │ │ │ +
265 template<typename... Indices>
│ │ │ │ +
│ │ │ │ +
266 ImplementationDefined& child (Indices... indices)
│ │ │ │ +
267#else
│ │ │ │ +
268 template<typename I0, typename... I,
│ │ │ │ +
269 std::enable_if_t<(sizeof...(I) > 0) || IsTreePath<I0>::value, int > = 0>
│ │ │ │ +
270 decltype(auto) child (I0 i0, I... i)
│ │ │ │ +
271#endif
│ │ │ │ +
272 {
│ │ │ │ +
273 static_assert(sizeof...(I) > 0 || impl::_non_empty_tree_path(I0{}),
│ │ │ │ +
274 "You cannot use the member function child() with an empty TreePath, use the freestanding version child(node,treePath) instead."
│ │ │ │ +
275 );
│ │ │ │ +
276 return Dune::TypeTree::child(*this,i0,i...);
│ │ │ │ +
277 }
│ │ │ │ +
│ │ │ │ +
278
│ │ │ │ +
280
│ │ │ │ +
284#ifdef DOXYGEN
│ │ │ │ +
285 template<typename... Indices>
│ │ │ │ +
│ │ │ │ +
286 const ImplementationDefined& child (Indices... indices)
│ │ │ │ +
287#else
│ │ │ │ +
288 template<typename I0, typename... I,
│ │ │ │ +
289 std::enable_if_t<(sizeof...(I) > 0) || IsTreePath<I0>::value, int > = 0>
│ │ │ │ +
290 decltype(auto) child (I0 i0, I... i) const
│ │ │ │ +
291#endif
│ │ │ │ +
292 {
│ │ │ │ +
293 static_assert(sizeof...(I) > 0 || impl::_non_empty_tree_path(I0{}),
│ │ │ │ +
294 "You cannot use the member function child() with an empty TreePath, use the freestanding version child(node,treePath) instead."
│ │ │ │ +
295 );
│ │ │ │ +
296 return Dune::TypeTree::child(*this,i0,i...);
│ │ │ │ +
297 }
│ │ │ │ +
│ │ │ │ +
298
│ │ │ │ +
300
│ │ │ │ +
303
│ │ │ │ +
304 protected:
│ │ │ │ +
305
│ │ │ │
307
│ │ │ │ -
315 template<typename T, typename TreePath, typename U>
│ │ │ │ -
316 auto post(T&&, TreePath, const U& u) const {return u;}
│ │ │ │ +
│ │ │ │ +
315 PowerNode ()
│ │ │ │ +
316 {}
│ │ │ │ +
│ │ │ │
317
│ │ │ │ -
325 template<typename T, typename TreePath, typename U>
│ │ │ │ -
326 auto leaf(T&&, TreePath, const U& u) const { return u;}
│ │ │ │ -
327
│ │ │ │ -
335 template<typename T, typename Child, typename TreePath, typename ChildIndex, typename U>
│ │ │ │ -
336 auto beforeChild(T&&, Child&&, TreePath, ChildIndex, const U& u) const {return u;}
│ │ │ │ +
│ │ │ │ +
319 explicit PowerNode (const NodeStorage& children)
│ │ │ │ +
320 : _children(children)
│ │ │ │ +
321 {}
│ │ │ │ +
│ │ │ │ +
322
│ │ │ │ +
│ │ │ │ +
324 explicit PowerNode (T& t, bool distinct_objects = true)
│ │ │ │ +
325 {
│ │ │ │ +
326 if (distinct_objects)
│ │ │ │ +
327 {
│ │ │ │ +
328 for (typename NodeStorage::iterator it = _children.begin(); it != _children.end(); ++it)
│ │ │ │ +
329 *it = std::make_shared<T>(t);
│ │ │ │ +
330 }
│ │ │ │ +
331 else
│ │ │ │ +
332 {
│ │ │ │ +
333 std::shared_ptr<T> sp = stackobject_to_shared_ptr(t);
│ │ │ │ +
334 std::fill(_children.begin(),_children.end(),sp);
│ │ │ │ +
335 }
│ │ │ │ +
336 }
│ │ │ │ +
│ │ │ │
337
│ │ │ │ -
345 template<typename T, typename Child, typename TreePath, typename ChildIndex, typename U>
│ │ │ │ -
346 auto afterChild(T&&, Child&&, TreePath, ChildIndex, const U& u) const {return u;}
│ │ │ │ -
347
│ │ │ │ -
348 };
│ │ │ │ -
│ │ │ │ -
349 } // namespace Experimental
│ │ │ │ -
350
│ │ │ │ -
352
│ │ │ │ -
│ │ │ │ -
357 struct VisitDirectChildren
│ │ │ │ -
358 {
│ │ │ │ -
359
│ │ │ │ -
360 // the little trick with the default template arguments
│ │ │ │ -
361 // makes the class usable for both single-tree visitors
│ │ │ │ -
362 // and visitors for pairs of trees
│ │ │ │ -
364 template<typename Node1,
│ │ │ │ -
365 typename Child1,
│ │ │ │ -
366 typename Node2,
│ │ │ │ -
367 typename Child2 = void,
│ │ │ │ -
368 typename TreePath = void>
│ │ │ │ -
│ │ │ │ -
369 struct VisitChild
│ │ │ │ -
370 {
│ │ │ │ -
372 static const bool value = false;
│ │ │ │ -
373 };
│ │ │ │ -
│ │ │ │ -
374
│ │ │ │ -
375 };
│ │ │ │ -
│ │ │ │ -
376
│ │ │ │ -
377
│ │ │ │ -
379
│ │ │ │ -
│ │ │ │ -
383 struct VisitTree
│ │ │ │ -
384 {
│ │ │ │ -
385
│ │ │ │ -
386 // the little trick with the default template arguments
│ │ │ │ -
387 // makes the class usable for both single-tree visitors
│ │ │ │ -
388 // and visitors for pairs of trees
│ │ │ │ -
390 template<typename Node1,
│ │ │ │ -
391 typename Child1,
│ │ │ │ -
392 typename Node2,
│ │ │ │ -
393 typename Child2 = void,
│ │ │ │ -
394 typename TreePath = void>
│ │ │ │ -
│ │ │ │ -
395 struct VisitChild
│ │ │ │ -
396 {
│ │ │ │ -
398 static const bool value = true;
│ │ │ │ -
399 };
│ │ │ │ -
│ │ │ │ -
400
│ │ │ │ -
401 };
│ │ │ │ -
│ │ │ │ -
402
│ │ │ │ -
404
│ │ │ │ -
│ │ │ │ -
411 struct StaticTraversal
│ │ │ │ -
412 {
│ │ │ │ -
414 static const TreePathType::Type treePathType = TreePathType::fullyStatic;
│ │ │ │ -
415 };
│ │ │ │ -
│ │ │ │ -
416
│ │ │ │ -
418
│ │ │ │ -
│ │ │ │ -
425 struct DynamicTraversal
│ │ │ │ -
426 {
│ │ │ │ -
428 static const TreePathType::Type treePathType = TreePathType::dynamic;
│ │ │ │ -
429 };
│ │ │ │ -
│ │ │ │ -
430
│ │ │ │ -
│ │ │ │ -
432 struct TreeVisitor
│ │ │ │ -
433 : public DefaultVisitor
│ │ │ │ -
434 , public VisitTree
│ │ │ │ -
435 {};
│ │ │ │ -
│ │ │ │ -
436
│ │ │ │ -
│ │ │ │ -
438 struct DirectChildrenVisitor
│ │ │ │ -
439 : public DefaultVisitor
│ │ │ │ -
440 , public VisitDirectChildren
│ │ │ │ -
441 {};
│ │ │ │ -
│ │ │ │ -
442
│ │ │ │ -
│ │ │ │ -
444 struct TreePairVisitor
│ │ │ │ -
445 : public DefaultPairVisitor
│ │ │ │ -
446 , public VisitTree
│ │ │ │ -
447 {};
│ │ │ │ -
│ │ │ │ -
448
│ │ │ │ -
│ │ │ │ -
450 struct DirectChildrenPairVisitor
│ │ │ │ -
451 : public DefaultPairVisitor
│ │ │ │ -
452 , public VisitDirectChildren
│ │ │ │ -
453 {};
│ │ │ │ -
│ │ │ │ -
454
│ │ │ │ -
│ │ │ │ -
455 namespace Experimental::Info {
│ │ │ │ -
456
│ │ │ │ -
│ │ │ │ -
457 struct LeafCounterVisitor
│ │ │ │ -
458 : public DefaultHybridVisitor
│ │ │ │ -
459 , public StaticTraversal
│ │ │ │ -
460 , public VisitTree
│ │ │ │ -
461 {
│ │ │ │ -
462 template<class Tree, class Child, class TreePath, class ChildIndex, class U>
│ │ │ │ -
│ │ │ │ -
463 auto beforeChild(Tree&&, Child&&, TreePath, ChildIndex, U u) const {
│ │ │ │ -
464 // in this case child index is an integral constant: forward u
│ │ │ │ -
465 return u;
│ │ │ │ -
466 }
│ │ │ │ -
│ │ │ │ -
467
│ │ │ │ -
468 template<class Tree, class Child, class TreePath, class U>
│ │ │ │ -
│ │ │ │ -
469 std::size_t beforeChild(Tree&&, Child&&, TreePath, std::size_t /*childIndex*/, U u) const {
│ │ │ │ -
470 // in this case child index is a run-time index: cast accumulated u to std::size_t
│ │ │ │ -
471 return std::size_t{u};
│ │ │ │ -
472 }
│ │ │ │ -
│ │ │ │ -
473
│ │ │ │ -
474 template<class Tree, class TreePath, class U>
│ │ │ │ -
│ │ │ │ -
475 auto leaf(Tree&&, TreePath, U u) const
│ │ │ │ -
476 {
│ │ │ │ -
477 return Hybrid::plus(u,Dune::Indices::_1);
│ │ │ │ -
478 }
│ │ │ │ -
│ │ │ │ -
479
│ │ │ │ -
480 };
│ │ │ │ -
│ │ │ │ -
481
│ │ │ │ -
│ │ │ │ -
482 struct NodeCounterVisitor
│ │ │ │ -
483 : public LeafCounterVisitor
│ │ │ │ -
484 {
│ │ │ │ -
485 template<typename Tree, typename TreePath, typename U>
│ │ │ │ -
│ │ │ │ -
486 auto pre(Tree&&, TreePath, U u) const {
│ │ │ │ -
487 return Hybrid::plus(u,Indices::_1);
│ │ │ │ -
488 }
│ │ │ │ -
│ │ │ │ -
489 };
│ │ │ │ -
│ │ │ │ -
490
│ │ │ │ -
│ │ │ │ -
491 struct DepthVisitor
│ │ │ │ -
492 : public DefaultHybridVisitor
│ │ │ │ -
493 , public StaticTraversal
│ │ │ │ -
494 , public VisitTree
│ │ │ │ -
495 {
│ │ │ │ -
496 template<class Tree, class TreePath, class U>
│ │ │ │ -
│ │ │ │ -
497 auto leaf(Tree&&, TreePath, U u) const
│ │ │ │ -
498 {
│ │ │ │ -
499 auto path_size = index_constant<treePathSize(TreePath{})>{};
│ │ │ │ -
500 auto depth = Hybrid::plus(path_size,Indices::_1);
│ │ │ │ -
501 return Hybrid::max(depth,u);
│ │ │ │ -
502 }
│ │ │ │ -
│ │ │ │ -
503 };
│ │ │ │ -
│ │ │ │ -
504
│ │ │ │ -
506 // result is alwayas an integral constant
│ │ │ │ -
507 template<typename Tree>
│ │ │ │ -
│ │ │ │ -
508 auto depth(const Tree& tree)
│ │ │ │ -
509 {
│ │ │ │ -
510 return hybridApplyToTree(tree,DepthVisitor{},Indices::_0);
│ │ │ │ -
511 }
│ │ │ │ -
│ │ │ │ -
512
│ │ │ │ -
514 // return types is std::integral_constant.
│ │ │ │ -
515 template<typename Tree>
│ │ │ │ -
│ │ │ │ -
516 constexpr auto depth()
│ │ │ │ -
517 {
│ │ │ │ -
518 return decltype(hybridApplyToTree(std::declval<Tree>(),DepthVisitor{},Indices::_0)){};
│ │ │ │ -
519 }
│ │ │ │ -
│ │ │ │ -
520
│ │ │ │ -
522 // if Tree is dynamic, return type is std::size_t, otherwise std::integral_constant.
│ │ │ │ -
523 template<typename Tree>
│ │ │ │ -
│ │ │ │ -
524 auto nodeCount(const Tree& tree)
│ │ │ │ -
525 {
│ │ │ │ -
526 return hybridApplyToTree(tree,NodeCounterVisitor{},Indices::_0);
│ │ │ │ -
527 }
│ │ │ │ -
│ │ │ │ -
528
│ │ │ │ -
530 // if Tree is dynamic, return type is std::size_t, otherwise std::integral_constant.
│ │ │ │ -
531 template<typename Tree>
│ │ │ │ -
│ │ │ │ -
532 auto leafCount(const Tree& tree)
│ │ │ │ -
533 {
│ │ │ │ -
534 return hybridApplyToTree(tree,LeafCounterVisitor{},Dune::Indices::_0);
│ │ │ │ -
535 }
│ │ │ │ -
│ │ │ │ -
536
│ │ │ │ -
538 template<typename Tree>
│ │ │ │ -
539 constexpr bool isDynamic = std::is_same<std::size_t, decltype(leafCount(std::declval<Tree>()))>{};
│ │ │ │ -
540
│ │ │ │ -
541 } // namespace Experimental::Info
│ │ │ │ -
│ │ │ │ -
542
│ │ │ │ -
544
│ │ │ │ -
545 } // namespace TypeTree
│ │ │ │ -
546} //namespace Dune
│ │ │ │ -
547
│ │ │ │ -
548#endif // DUNE_TYPETREE_VISITOR_HH
│ │ │ │ - │ │ │ │ -
Dune::TypeTree::Child
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
│ │ │ │ -
Dune::TypeTree::treePathSize
constexpr std::size_t treePathSize(const HybridTreePath< T... > &)
Returns the size (number of components) of the given HybridTreePath.
Definition treepath.hh:334
│ │ │ │ +
338#ifdef DOXYGEN
│ │ │ │ +
339
│ │ │ │ +
│ │ │ │ +
341 PowerNode(T& t1, T& t2, ...)
│ │ │ │ +
342 {}
│ │ │ │ +
│ │ │ │ +
343
│ │ │ │ +
344#else
│ │ │ │ +
345
│ │ │ │ +
346 template<typename... Children,
│ │ │ │ +
347 std::enable_if_t<
│ │ │ │ +
348 std::conjunction<std::is_same<ChildType, std::decay_t<Children>>...>::value
│ │ │ │ +
349 ,int> = 0>
│ │ │ │ +
350 PowerNode (Children&&... children)
│ │ │ │ +
351 {
│ │ │ │ +
352 static_assert(degree() == sizeof...(Children), "PowerNode constructor is called with incorrect number of children");
│ │ │ │ +
353 _children = NodeStorage{convert_arg(std::forward<Children>(children))...};
│ │ │ │ +
354 }
│ │ │ │ +
355
│ │ │ │ +
356 template<typename... Children,
│ │ │ │ +
357 std::enable_if_t<
│ │ │ │ +
358 std::conjunction<std::is_same<ChildType, Children>...>::value
│ │ │ │ +
359 ,int> = 0>
│ │ │ │ +
360 PowerNode (std::shared_ptr<Children>... children)
│ │ │ │ +
361 {
│ │ │ │ +
362 static_assert(degree() == sizeof...(Children), "PowerNode constructor is called with incorrect number of children");
│ │ │ │ +
363 _children = NodeStorage{children...};
│ │ │ │ +
364 }
│ │ │ │ +
365
│ │ │ │ +
366#endif // DOXYGEN
│ │ │ │ +
367
│ │ │ │ +
369
│ │ │ │ +
370 private:
│ │ │ │ +
371 NodeStorage _children;
│ │ │ │ +
372 };
│ │ │ │ +
│ │ │ │ +
373
│ │ │ │ +
375
│ │ │ │ +
376 } // namespace TypeTree
│ │ │ │ +
377} //namespace Dune
│ │ │ │ +
378
│ │ │ │ +
379#endif // DUNE_TYPETREE_POWERNODE_HH
│ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +
Dune::TypeTree::child
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
│ │ │ │
Dune
Definition accumulate_static.hh:16
│ │ │ │ -
Dune::TypeTree::Experimental::hybridApplyToTree
auto hybridApplyToTree(Tree &&tree, Visitor &&visitor, Init &&init)
Apply hybrid visitor to TypeTree.
Definition accumulate_static.hh:701
│ │ │ │ -
Dune::TypeTree::TreePathType::Type
Type
Definition treepath.hh:106
│ │ │ │ -
Dune::TypeTree::TreePathType::fullyStatic
@ fullyStatic
Definition treepath.hh:106
│ │ │ │ -
Dune::TypeTree::TreePathType::dynamic
@ dynamic
Definition treepath.hh:106
│ │ │ │ -
Dune::TypeTree::Experimental::Info::isDynamic
constexpr bool isDynamic
true if any of the nodes in the tree only has dynamic degree.
Definition visitor.hh:539
│ │ │ │ -
Dune::TypeTree::Experimental::Info::leafCount
auto leafCount(const Tree &tree)
The number of leaf nodes in the Tree.
Definition visitor.hh:532
│ │ │ │ -
Dune::TypeTree::Experimental::Info::nodeCount
auto nodeCount(const Tree &tree)
The total number of nodes in the Tree.
Definition visitor.hh:524
│ │ │ │ -
Dune::TypeTree::Experimental::Info::depth
constexpr auto depth()
The depth of the Tree.
Definition visitor.hh:516
│ │ │ │ -
Dune::TypeTree::DefaultVisitor
Visitor interface and base class for TypeTree visitors.
Definition visitor.hh:49
│ │ │ │ -
Dune::TypeTree::DefaultVisitor::in
void in(T &&, TreePath) const
Method for infix tree traversal.
Definition visitor.hh:72
│ │ │ │ -
Dune::TypeTree::DefaultVisitor::afterChild
void afterChild(T &&, Child &&, TreePath, ChildIndex) const
Method for child-parent traversal.
Definition visitor.hh:122
│ │ │ │ -
Dune::TypeTree::DefaultVisitor::beforeChild
void beforeChild(T &&, Child &&, TreePath, ChildIndex) const
Method for parent-child traversal.
Definition visitor.hh:107
│ │ │ │ -
Dune::TypeTree::DefaultVisitor::post
void post(T &&, TreePath) const
Method for postfix tree traversal.
Definition visitor.hh:83
│ │ │ │ -
Dune::TypeTree::DefaultVisitor::leaf
void leaf(T &&, TreePath) const
Method for leaf traversal.
Definition visitor.hh:93
│ │ │ │ -
Dune::TypeTree::DefaultVisitor::pre
void pre(T &&, TreePath) const
Method for prefix tree traversal.
Definition visitor.hh:60
│ │ │ │ -
Dune::TypeTree::DefaultPairVisitor
Visitor interface and base class for visitors of pairs of TypeTrees.
Definition visitor.hh:164
│ │ │ │ -
Dune::TypeTree::DefaultPairVisitor::leaf
void leaf(T1 &&, T2 &&, TreePath) const
Method for leaf traversal.
Definition visitor.hh:216
│ │ │ │ -
Dune::TypeTree::DefaultPairVisitor::beforeChild
void beforeChild(T1 &&, Child1 &&, T2 &&, Child2 &&, TreePath, ChildIndex) const
Method for parent-child traversal.
Definition visitor.hh:232
│ │ │ │ -
Dune::TypeTree::DefaultPairVisitor::pre
void pre(T1 &&, T2 &&, TreePath) const
Method for prefix tree traversal.
Definition visitor.hh:176
│ │ │ │ -
Dune::TypeTree::DefaultPairVisitor::post
void post(T1 &&, T2 &&, TreePath) const
Method for postfix traversal.
Definition visitor.hh:201
│ │ │ │ -
Dune::TypeTree::DefaultPairVisitor::in
void in(T1 &&, T2 &&, TreePath) const
Method for infix tree traversal.
Definition visitor.hh:189
│ │ │ │ -
Dune::TypeTree::DefaultPairVisitor::afterChild
void afterChild(T1 &&, Child1 &&, T2 &&, Child2 &&, TreePath, ChildIndex) const
Method for child-parent traversal.
Definition visitor.hh:248
│ │ │ │ -
Dune::TypeTree::Experimental::DefaultHybridVisitor
Hybrid visitor interface and base class for TypeTree hybrid visitors.
Definition visitor.hh:286
│ │ │ │ -
Dune::TypeTree::Experimental::DefaultHybridVisitor::post
auto post(T &&, TreePath, const U &u) const
Method for postfix tree traversal.
Definition visitor.hh:316
│ │ │ │ -
Dune::TypeTree::Experimental::DefaultHybridVisitor::pre
auto pre(T &&, TreePath, const U &u) const
Method for prefix tree traversal.
Definition visitor.hh:296
│ │ │ │ -
Dune::TypeTree::Experimental::DefaultHybridVisitor::leaf
auto leaf(T &&, TreePath, const U &u) const
Method for leaf traversal.
Definition visitor.hh:326
│ │ │ │ -
Dune::TypeTree::Experimental::DefaultHybridVisitor::afterChild
auto afterChild(T &&, Child &&, TreePath, ChildIndex, const U &u) const
Method for child-parent traversal.
Definition visitor.hh:346
│ │ │ │ -
Dune::TypeTree::Experimental::DefaultHybridVisitor::in
auto in(T &&, TreePath, const U &u) const
Method for infix tree traversal.
Definition visitor.hh:306
│ │ │ │ -
Dune::TypeTree::Experimental::DefaultHybridVisitor::beforeChild
auto beforeChild(T &&, Child &&, TreePath, ChildIndex, const U &u) const
Method for parent-child traversal.
Definition visitor.hh:336
│ │ │ │ -
Dune::TypeTree::VisitDirectChildren
Mixin base class for visitors that only want to visit the direct children of a node.
Definition visitor.hh:358
│ │ │ │ -
Dune::TypeTree::VisitDirectChildren::VisitChild
Template struct for determining whether or not to visit a given child.
Definition visitor.hh:370
│ │ │ │ -
Dune::TypeTree::VisitDirectChildren::VisitChild::value
static const bool value
Do not visit any child.
Definition visitor.hh:372
│ │ │ │ -
Dune::TypeTree::VisitTree
Mixin base class for visitors that want to visit the complete tree.
Definition visitor.hh:384
│ │ │ │ -
Dune::TypeTree::VisitTree::VisitChild
Template struct for determining whether or not to visit a given child.
Definition visitor.hh:396
│ │ │ │ -
Dune::TypeTree::VisitTree::VisitChild::value
static const bool value
Visit any child.
Definition visitor.hh:398
│ │ │ │ -
Dune::TypeTree::StaticTraversal
Mixin base class for visitors that require a static TreePath during traversal.
Definition visitor.hh:412
│ │ │ │ -
Dune::TypeTree::StaticTraversal::treePathType
static const TreePathType::Type treePathType
Use the static tree traversal algorithm.
Definition visitor.hh:414
│ │ │ │ -
Dune::TypeTree::DynamicTraversal
Mixin base class for visitors that only need a dynamic TreePath during traversal.
Definition visitor.hh:426
│ │ │ │ -
Dune::TypeTree::DynamicTraversal::treePathType
static const TreePathType::Type treePathType
Use the dynamic tree traversal algorithm.
Definition visitor.hh:428
│ │ │ │ -
Dune::TypeTree::TreeVisitor
Convenience base class for visiting the entire tree.
Definition visitor.hh:435
│ │ │ │ -
Dune::TypeTree::DirectChildrenVisitor
Convenience base class for visiting the direct children of a node.
Definition visitor.hh:441
│ │ │ │ -
Dune::TypeTree::TreePairVisitor
Convenience base class for visiting an entire tree pair.
Definition visitor.hh:447
│ │ │ │ -
Dune::TypeTree::DirectChildrenPairVisitor
Convenience base class for visiting the direct children of a node pair.
Definition visitor.hh:453
│ │ │ │ - │ │ │ │ -
Dune::TypeTree::Experimental::Info::LeafCounterVisitor::leaf
auto leaf(Tree &&, TreePath, U u) const
Definition visitor.hh:475
│ │ │ │ -
Dune::TypeTree::Experimental::Info::LeafCounterVisitor::beforeChild
auto beforeChild(Tree &&, Child &&, TreePath, ChildIndex, U u) const
Definition visitor.hh:463
│ │ │ │ -
Dune::TypeTree::Experimental::Info::LeafCounterVisitor::beforeChild
std::size_t beforeChild(Tree &&, Child &&, TreePath, std::size_t, U u) const
Definition visitor.hh:469
│ │ │ │ - │ │ │ │ -
Dune::TypeTree::Experimental::Info::NodeCounterVisitor::pre
auto pre(Tree &&, TreePath, U u) const
Definition visitor.hh:486
│ │ │ │ - │ │ │ │ -
Dune::TypeTree::Experimental::Info::DepthVisitor::leaf
auto leaf(Tree &&, TreePath, U u) const
Definition visitor.hh:497
│ │ │ │ +
Dune::TypeTree::PowerNodeTag
Tag designating a power node.
Definition nodetags.hh:21
│ │ │ │ +
Dune::TypeTree::PowerNode
Collect k instances of type T within a dune-typetree.
Definition powernode.hh:52
│ │ │ │ +
Dune::TypeTree::PowerNode::setChild
void setChild(T &t, index_constant< i >={})
Sets the i-th child to the passed-in value.
Definition powernode.hh:143
│ │ │ │ +
Dune::TypeTree::PowerNode::child
T & child(std::size_t i)
Returns the i-th child.
Definition powernode.hh:175
│ │ │ │ +
Dune::TypeTree::PowerNode::child
const T & child(index_constant< i >={}) const
Returns the i-th child (const version).
Definition powernode.hh:113
│ │ │ │ +
Dune::TypeTree::PowerNode::setChild
void setChild(std::shared_ptr< T > st, index_constant< i >={})
Sets the stored value representing the i-th child to the passed-in value.
Definition powernode.hh:159
│ │ │ │ +
Dune::TypeTree::PowerNode::childStorage
std::shared_ptr< T > childStorage(index_constant< i >={})
Returns the storage of the i-th child.
Definition powernode.hh:124
│ │ │ │ +
Dune::TypeTree::PowerNode::PowerNode
PowerNode(T &t1, T &t2,...)
Initialize all children with the passed-in objects.
Definition powernode.hh:341
│ │ │ │ +
Dune::TypeTree::PowerNode::nodeStorage
const NodeStorage & nodeStorage() const
Definition powernode.hh:232
│ │ │ │ +
Dune::TypeTree::PowerNode::NodeStorage
std::array< std::shared_ptr< T >, k > NodeStorage
The type used for storing the children.
Definition powernode.hh:77
│ │ │ │ +
Dune::TypeTree::PowerNode::childStorage
std::shared_ptr< const T > childStorage(index_constant< i >={}) const
Returns the storage of the i-th child (const version).
Definition powernode.hh:135
│ │ │ │ +
Dune::TypeTree::PowerNode::PowerNode
PowerNode(T &t, bool distinct_objects=true)
Initialize all children with copies of a storage object constructed from the parameter t.
Definition powernode.hh:324
│ │ │ │ +
Dune::TypeTree::PowerNode::NodeTag
PowerNodeTag NodeTag
The type tag that describes a PowerNode.
Definition powernode.hh:71
│ │ │ │ +
Dune::TypeTree::PowerNode::child
const T & child(std::size_t i) const
Returns the i-th child (const version).
Definition powernode.hh:185
│ │ │ │ +
Dune::TypeTree::PowerNode::degree
static constexpr auto degree()
Definition powernode.hh:65
│ │ │ │ +
Dune::TypeTree::PowerNode::childStorage
std::shared_ptr< const T > childStorage(std::size_t i) const
Returns the storage of the i-th child (const version).
Definition powernode.hh:205
│ │ │ │ +
Dune::TypeTree::PowerNode::setChild
void setChild(std::size_t i, std::shared_ptr< T > st)
Sets the stored value representing the i-th child to the passed-in value.
Definition powernode.hh:226
│ │ │ │ +
Dune::TypeTree::PowerNode::isComposite
static const bool isComposite
Mark this class as a non composite in the dune-typetree.
Definition powernode.hh:63
│ │ │ │ +
Dune::TypeTree::PowerNode::isLeaf
static const bool isLeaf
Mark this class as non leaf in the dune-typetree.
Definition powernode.hh:57
│ │ │ │ +
Dune::TypeTree::PowerNode::isPower
static const bool isPower
Mark this class as a power in the dune-typetree.
Definition powernode.hh:60
│ │ │ │ +
Dune::TypeTree::PowerNode::PowerNode
PowerNode(const NodeStorage &children)
Initialize the PowerNode with a copy of the passed-in storage type.
Definition powernode.hh:319
│ │ │ │ +
Dune::TypeTree::PowerNode::ChildType
T ChildType
The type of each child.
Definition powernode.hh:74
│ │ │ │ +
Dune::TypeTree::PowerNode::child
T & child(index_constant< i >={})
Returns the i-th child.
Definition powernode.hh:102
│ │ │ │ +
Dune::TypeTree::PowerNode::child
ImplementationDefined & child(Indices... indices)
Returns the child given by the list of indices.
Definition powernode.hh:266
│ │ │ │ +
Dune::TypeTree::PowerNode::setChild
void setChild(std::size_t i, T &&t)
Store the passed value in i-th child.
Definition powernode.hh:219
│ │ │ │ +
Dune::TypeTree::PowerNode::setChild
void setChild(T &&t, index_constant< i >={})
Store the passed value in i-th child.
Definition powernode.hh:151
│ │ │ │ +
Dune::TypeTree::PowerNode::PowerNode
PowerNode()
Default constructor.
Definition powernode.hh:315
│ │ │ │ +
Dune::TypeTree::PowerNode::child
const ImplementationDefined & child(Indices... indices)
Returns the child given by the list of indices.
Definition powernode.hh:286
│ │ │ │ +
Dune::TypeTree::PowerNode::setChild
void setChild(std::size_t i, T &t)
Sets the i-th child to the passed-in value.
Definition powernode.hh:212
│ │ │ │ +
Dune::TypeTree::PowerNode::childStorage
std::shared_ptr< T > childStorage(std::size_t i)
Returns the storage of the i-th child.
Definition powernode.hh:195
│ │ │ │ +
Dune::TypeTree::PowerNode::Child
Access to the type and storage type of the i-th child.
Definition powernode.hh:83
│ │ │ │ +
Dune::TypeTree::PowerNode::Child::type
T type
The type of the child.
Definition powernode.hh:91
│ │ │ │ +
Dune::TypeTree::PowerNode::Child::Type
T Type
The type of the child.
Definition powernode.hh:88
│ │ │ │ +
Dune::TypeTree::IsTreePath
Check if type represents a tree path.
Definition typetraits.hh:184
│ │ │ │
│ │ │ │ │ │ │ │
│ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,481 +1,463 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -visitor.hh │ │ │ │ │ +powernode.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_VISITOR_HH │ │ │ │ │ -7#define DUNE_TYPETREE_VISITOR_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_POWERNODE_HH │ │ │ │ │ +7#define DUNE_TYPETREE_POWERNODE_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_e_e_p_a_t_h_._h_h> │ │ │ │ │ -10#include │ │ │ │ │ -11 │ │ │ │ │ -12namespace _D_u_n_e { │ │ │ │ │ -13 namespace TypeTree { │ │ │ │ │ -14 │ │ │ │ │ +9#include │ │ │ │ │ +10#include │ │ │ │ │ +11#include │ │ │ │ │ +12#include │ │ │ │ │ +13 │ │ │ │ │ +14#include │ │ │ │ │ +15#include │ │ │ │ │ +16 │ │ │ │ │ +17#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ +18#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_u_t_i_l_i_t_y_._h_h> │ │ │ │ │ +19#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h> │ │ │ │ │ +20#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_y_p_e_t_r_a_i_t_s_._h_h> │ │ │ │ │ 21 │ │ │ │ │ -_4_8 struct _D_e_f_a_u_l_t_V_i_s_i_t_o_r │ │ │ │ │ -49 { │ │ │ │ │ -50 │ │ │ │ │ -52 │ │ │ │ │ -59 template │ │ │ │ │ -_6_0 void _p_r_e(T&&, TreePath) const {} │ │ │ │ │ +22namespace _D_u_n_e { │ │ │ │ │ +23 namespace TypeTree { │ │ │ │ │ +24 │ │ │ │ │ +31#ifndef DOXYGEN │ │ │ │ │ +32 │ │ │ │ │ +34 template │ │ │ │ │ +35 struct AssertPowerNodeChildCount │ │ │ │ │ +36 : public std::enable_if::value && │ │ │ │ │ +39 PowerNode::degree() == k, │ │ │ │ │ +40 T> │ │ │ │ │ +41 {}; │ │ │ │ │ +42 │ │ │ │ │ +43#endif │ │ │ │ │ +44 │ │ │ │ │ +50 template │ │ │ │ │ +_5_1 class _P_o_w_e_r_N_o_d_e │ │ │ │ │ +52 { │ │ │ │ │ +53 │ │ │ │ │ +54 public: │ │ │ │ │ +55 │ │ │ │ │ +_5_7 static const bool _i_s_L_e_a_f = false; │ │ │ │ │ +58 │ │ │ │ │ +_6_0 static const bool _i_s_P_o_w_e_r = true; │ │ │ │ │ 61 │ │ │ │ │ -63 │ │ │ │ │ -71 template │ │ │ │ │ -_7_2 void _i_n(T&&, TreePath) const {} │ │ │ │ │ -73 │ │ │ │ │ +_6_3 static const bool _i_s_C_o_m_p_o_s_i_t_e = false; │ │ │ │ │ +64 │ │ │ │ │ +_6_5 static constexpr auto _d_e_g_r_e_e () │ │ │ │ │ +66 { │ │ │ │ │ +67 return std::integral_constant{}; │ │ │ │ │ +68 } │ │ │ │ │ +69 │ │ │ │ │ +_7_1 typedef _P_o_w_e_r_N_o_d_e_T_a_g _N_o_d_e_T_a_g; │ │ │ │ │ +72 │ │ │ │ │ +_7_4 typedef T _C_h_i_l_d_T_y_p_e; │ │ │ │ │ 75 │ │ │ │ │ -82 template │ │ │ │ │ -_8_3 void _p_o_s_t(T&&, TreePath) const {} │ │ │ │ │ +_7_7 typedef std::array,k> _N_o_d_e_S_t_o_r_a_g_e; │ │ │ │ │ +78 │ │ │ │ │ +79 │ │ │ │ │ +81 template │ │ │ │ │ +_8_2 struct _C_h_i_l_d │ │ │ │ │ +83 { │ │ │ │ │ 84 │ │ │ │ │ +85 static_assert((i < _d_e_g_r_e_e()), "child index out of range"); │ │ │ │ │ 86 │ │ │ │ │ -92 template │ │ │ │ │ -_9_3 void _l_e_a_f(T&&, TreePath) const {} │ │ │ │ │ -94 │ │ │ │ │ +_8_8 typedef T _T_y_p_e; │ │ │ │ │ +89 │ │ │ │ │ +_9_1 typedef T _t_y_p_e; │ │ │ │ │ +92 }; │ │ │ │ │ +93 │ │ │ │ │ 96 │ │ │ │ │ -106 template │ │ │ │ │ -_1_0_7 void _b_e_f_o_r_e_C_h_i_l_d(T&&, _C_h_i_l_d&&, TreePath, ChildIndex) const {} │ │ │ │ │ -108 │ │ │ │ │ -110 │ │ │ │ │ -121 template │ │ │ │ │ -_1_2_2 void _a_f_t_e_r_C_h_i_l_d(T&&, _C_h_i_l_d&&, TreePath, ChildIndex) const {} │ │ │ │ │ -123 │ │ │ │ │ -124 }; │ │ │ │ │ -125 │ │ │ │ │ -126 │ │ │ │ │ -128 │ │ │ │ │ -_1_6_3 struct _D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ -164 { │ │ │ │ │ -165 │ │ │ │ │ +98 │ │ │ │ │ +101 template │ │ │ │ │ +_1_0_2 T& _c_h_i_l_d (index_constant = {}) │ │ │ │ │ +103 { │ │ │ │ │ +104 static_assert((i < _d_e_g_r_e_e()), "child index out of range"); │ │ │ │ │ +105 return *_children[i]; │ │ │ │ │ +106 } │ │ │ │ │ +107 │ │ │ │ │ +109 │ │ │ │ │ +112 template │ │ │ │ │ +_1_1_3 const T& _c_h_i_l_d (index_constant = {}) const │ │ │ │ │ +114 { │ │ │ │ │ +115 static_assert((i < _d_e_g_r_e_e()), "child index out of range"); │ │ │ │ │ +116 return *_children[i]; │ │ │ │ │ +117 } │ │ │ │ │ +118 │ │ │ │ │ +120 │ │ │ │ │ +123 template │ │ │ │ │ +_1_2_4 std::shared_ptr _c_h_i_l_d_S_t_o_r_a_g_e (index_constant = {}) │ │ │ │ │ +125 { │ │ │ │ │ +126 static_assert((i < _d_e_g_r_e_e()), "child index out of range"); │ │ │ │ │ +127 return _children[i]; │ │ │ │ │ +128 } │ │ │ │ │ +129 │ │ │ │ │ +131 │ │ │ │ │ +134 template │ │ │ │ │ +_1_3_5 std::shared_ptr _c_h_i_l_d_S_t_o_r_a_g_e (index_constant = {}) const │ │ │ │ │ +136 { │ │ │ │ │ +137 static_assert((i < _d_e_g_r_e_e()), "child index out of range"); │ │ │ │ │ +138 return _children[i]; │ │ │ │ │ +139 } │ │ │ │ │ +140 │ │ │ │ │ +142 template │ │ │ │ │ +_1_4_3 void _s_e_t_C_h_i_l_d (T& t, index_constant = {}) │ │ │ │ │ +144 { │ │ │ │ │ +145 static_assert((i < _d_e_g_r_e_e()), "child index out of range"); │ │ │ │ │ +146 _children[i] = stackobject_to_shared_ptr(t); │ │ │ │ │ +147 } │ │ │ │ │ +148 │ │ │ │ │ +150 template │ │ │ │ │ +_1_5_1 void _s_e_t_C_h_i_l_d (T&& t, index_constant = {}) │ │ │ │ │ +152 { │ │ │ │ │ +153 static_assert((i < _d_e_g_r_e_e()), "child index out of range"); │ │ │ │ │ +154 _children[i] = convert_arg(std::move(t)); │ │ │ │ │ +155 } │ │ │ │ │ +156 │ │ │ │ │ +158 template │ │ │ │ │ +_1_5_9 void _s_e_t_C_h_i_l_d (std::shared_ptr st, index_constant = {}) │ │ │ │ │ +160 { │ │ │ │ │ +161 static_assert((i < _d_e_g_r_e_e()), "child index out of range"); │ │ │ │ │ +162 _children[i] = std::move(st); │ │ │ │ │ +163 } │ │ │ │ │ +164 │ │ │ │ │ +166 │ │ │ │ │ 167 │ │ │ │ │ -175 template │ │ │ │ │ -_1_7_6 void _p_r_e(T1&&, T2&&, TreePath) const {} │ │ │ │ │ -177 │ │ │ │ │ -179 │ │ │ │ │ -188 template │ │ │ │ │ -_1_8_9 void _i_n(T1&&, T2&&, TreePath) const {} │ │ │ │ │ +170 │ │ │ │ │ +172 │ │ │ │ │ +_1_7_5 T& _c_h_i_l_d (std::size_t i) │ │ │ │ │ +176 { │ │ │ │ │ +177 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ +178 return *_children[i]; │ │ │ │ │ +179 } │ │ │ │ │ +180 │ │ │ │ │ +182 │ │ │ │ │ +_1_8_5 const T& _c_h_i_l_d (std::size_t i) const │ │ │ │ │ +186 { │ │ │ │ │ +187 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ +188 return *_children[i]; │ │ │ │ │ +189 } │ │ │ │ │ 190 │ │ │ │ │ 192 │ │ │ │ │ -200 template │ │ │ │ │ -_2_0_1 void _p_o_s_t(T1&&, T2&&, TreePath) const {} │ │ │ │ │ +_1_9_5 std::shared_ptr _c_h_i_l_d_S_t_o_r_a_g_e (std::size_t i) │ │ │ │ │ +196 { │ │ │ │ │ +197 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ +198 return _children[i]; │ │ │ │ │ +199 } │ │ │ │ │ +200 │ │ │ │ │ 202 │ │ │ │ │ -204 │ │ │ │ │ -215 template │ │ │ │ │ -_2_1_6 void _l_e_a_f(T1&&, T2&&, TreePath) const {} │ │ │ │ │ +_2_0_5 std::shared_ptr _c_h_i_l_d_S_t_o_r_a_g_e (std::size_t i) const │ │ │ │ │ +206 { │ │ │ │ │ +207 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ +208 return _children[i]; │ │ │ │ │ +209 } │ │ │ │ │ +210 │ │ │ │ │ +_2_1_2 void _s_e_t_C_h_i_l_d (std::size_t i, T& t) │ │ │ │ │ +213 { │ │ │ │ │ +214 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ +215 _children[i] = stackobject_to_shared_ptr(t); │ │ │ │ │ +216 } │ │ │ │ │ 217 │ │ │ │ │ -219 │ │ │ │ │ -231 template │ │ │ │ │ -_2_3_2 void _b_e_f_o_r_e_C_h_i_l_d(T1&&, Child1&&, T2&&, Child2&&, TreePath, ChildIndex) │ │ │ │ │ -const {} │ │ │ │ │ -233 │ │ │ │ │ -235 │ │ │ │ │ -247 template │ │ │ │ │ -_2_4_8 void _a_f_t_e_r_C_h_i_l_d(T1&&, Child1&&, T2&&, Child2&&, TreePath, ChildIndex) const │ │ │ │ │ -{} │ │ │ │ │ -249 │ │ │ │ │ -250 }; │ │ │ │ │ -251 │ │ │ │ │ -252 │ │ │ │ │ -253 namespace Experimental { │ │ │ │ │ -254 │ │ │ │ │ -_2_8_5 struct _D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r │ │ │ │ │ -286 { │ │ │ │ │ -287 │ │ │ │ │ -295 template │ │ │ │ │ -_2_9_6 auto _p_r_e(T&&, TreePath, const U& u) const { return u;} │ │ │ │ │ -297 │ │ │ │ │ -305 template │ │ │ │ │ -_3_0_6 auto _i_n(T&&, TreePath, const U& u) const {return u;} │ │ │ │ │ +_2_1_9 void _s_e_t_C_h_i_l_d (std::size_t i, T&& t) │ │ │ │ │ +220 { │ │ │ │ │ +221 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ +222 _children[i] = convert_arg(std::move(t)); │ │ │ │ │ +223 } │ │ │ │ │ +224 │ │ │ │ │ +_2_2_6 void _s_e_t_C_h_i_l_d (std::size_t i, std::shared_ptr st) │ │ │ │ │ +227 { │ │ │ │ │ +228 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ +229 _children[i] = std::move(st); │ │ │ │ │ +230 } │ │ │ │ │ +231 │ │ │ │ │ +_2_3_2 const _N_o_d_e_S_t_o_r_a_g_e& _n_o_d_e_S_t_o_r_a_g_e () const │ │ │ │ │ +233 { │ │ │ │ │ +234 return _children; │ │ │ │ │ +235 } │ │ │ │ │ +236 │ │ │ │ │ +238 │ │ │ │ │ +241 │ │ │ │ │ +242 // The following two methods require a little bit of SFINAE trickery to │ │ │ │ │ +work correctly: │ │ │ │ │ +243 // We have to make sure that they don't shadow the methods for direct child │ │ │ │ │ +access because │ │ │ │ │ +244 // those get called by the generic child() machinery. If that machinery │ │ │ │ │ +picks up the methods │ │ │ │ │ +245 // defined below, we have an infinite recursion. │ │ │ │ │ +246 // So the methods make sure that either │ │ │ │ │ +247 // │ │ │ │ │ +248 // * there are more than one argument. In that case, we got multiple │ │ │ │ │ +indices and can forward │ │ │ │ │ +249 // to the general machine. │ │ │ │ │ +250 // │ │ │ │ │ +251 // * the first argument is not a valid flat index, i.e. either a std:: │ │ │ │ │ +size_t or an index_constant. │ │ │ │ │ +252 // The argument thus has to be some kind of TreePath instance that we can │ │ │ │ │ +also pass to the │ │ │ │ │ +253 // generic machine. │ │ │ │ │ +254 // │ │ │ │ │ +255 // The above SFINAE logic works, but there is still a problem with the │ │ │ │ │ +return type deduction. │ │ │ │ │ +256 // We have to do a lazy lookup of the return type after SFINAE has │ │ │ │ │ +succeeded, otherwise the return │ │ │ │ │ +257 // type deduction will trigger the infinite recursion. │ │ │ │ │ +258 │ │ │ │ │ +260 │ │ │ │ │ +264#ifdef DOXYGEN │ │ │ │ │ +265 template │ │ │ │ │ +_2_6_6 ImplementationDefined& _c_h_i_l_d (Indices... indices) │ │ │ │ │ +267#else │ │ │ │ │ +268 template 0) || _I_s_T_r_e_e_P_a_t_h_<_I_0_>_:_:_v_a_l_u_e, int > = 0> │ │ │ │ │ +270 decltype(auto) _c_h_i_l_d (I0 i0, I... i) │ │ │ │ │ +271#endif │ │ │ │ │ +272 { │ │ │ │ │ +273 static_assert(sizeof...(I) > 0 || impl::_non_empty_tree_path(I0{}), │ │ │ │ │ +274 "You cannot use the member function child() with an empty TreePath, use the │ │ │ │ │ +freestanding version child(node,treePath) instead." │ │ │ │ │ +275 ); │ │ │ │ │ +276 return _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_c_h_i_l_d(*this,i0,i...); │ │ │ │ │ +277 } │ │ │ │ │ +278 │ │ │ │ │ +280 │ │ │ │ │ +284#ifdef DOXYGEN │ │ │ │ │ +285 template │ │ │ │ │ +_2_8_6 const ImplementationDefined& _c_h_i_l_d (Indices... indices) │ │ │ │ │ +287#else │ │ │ │ │ +288 template 0) || _I_s_T_r_e_e_P_a_t_h_<_I_0_>_:_:_v_a_l_u_e, int > = 0> │ │ │ │ │ +290 decltype(auto) _c_h_i_l_d (I0 i0, I... i) const │ │ │ │ │ +291#endif │ │ │ │ │ +292 { │ │ │ │ │ +293 static_assert(sizeof...(I) > 0 || impl::_non_empty_tree_path(I0{}), │ │ │ │ │ +294 "You cannot use the member function child() with an empty TreePath, use the │ │ │ │ │ +freestanding version child(node,treePath) instead." │ │ │ │ │ +295 ); │ │ │ │ │ +296 return _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_c_h_i_l_d(*this,i0,i...); │ │ │ │ │ +297 } │ │ │ │ │ +298 │ │ │ │ │ +300 │ │ │ │ │ +303 │ │ │ │ │ +304 protected: │ │ │ │ │ +305 │ │ │ │ │ 307 │ │ │ │ │ -315 template │ │ │ │ │ -_3_1_6 auto _p_o_s_t(T&&, TreePath, const U& u) const {return u;} │ │ │ │ │ +_3_1_5 _P_o_w_e_r_N_o_d_e () │ │ │ │ │ +316 {} │ │ │ │ │ 317 │ │ │ │ │ -325 template │ │ │ │ │ -_3_2_6 auto _l_e_a_f(T&&, TreePath, const U& u) const { return u;} │ │ │ │ │ -327 │ │ │ │ │ -335 template │ │ │ │ │ -_3_3_6 auto _b_e_f_o_r_e_C_h_i_l_d(T&&, _C_h_i_l_d&&, TreePath, ChildIndex, const U& u) const │ │ │ │ │ -{return u;} │ │ │ │ │ +_3_1_9 explicit _P_o_w_e_r_N_o_d_e (const _N_o_d_e_S_t_o_r_a_g_e& children) │ │ │ │ │ +320 : _children(children) │ │ │ │ │ +321 {} │ │ │ │ │ +322 │ │ │ │ │ +_3_2_4 explicit _P_o_w_e_r_N_o_d_e (T& t, bool distinct_objects = true) │ │ │ │ │ +325 { │ │ │ │ │ +326 if (distinct_objects) │ │ │ │ │ +327 { │ │ │ │ │ +328 for (typename NodeStorage::iterator it = _children.begin(); it != │ │ │ │ │ +_children.end(); ++it) │ │ │ │ │ +329 *it = std::make_shared(t); │ │ │ │ │ +330 } │ │ │ │ │ +331 else │ │ │ │ │ +332 { │ │ │ │ │ +333 std::shared_ptr sp = stackobject_to_shared_ptr(t); │ │ │ │ │ +334 std::fill(_children.begin(),_children.end(),sp); │ │ │ │ │ +335 } │ │ │ │ │ +336 } │ │ │ │ │ 337 │ │ │ │ │ -345 template │ │ │ │ │ -_3_4_6 auto _a_f_t_e_r_C_h_i_l_d(T&&, _C_h_i_l_d&&, TreePath, ChildIndex, const U& u) const │ │ │ │ │ -{return u;} │ │ │ │ │ -347 │ │ │ │ │ -348 }; │ │ │ │ │ -349 } // namespace Experimental │ │ │ │ │ -350 │ │ │ │ │ -352 │ │ │ │ │ -_3_5_7 struct _V_i_s_i_t_D_i_r_e_c_t_C_h_i_l_d_r_e_n │ │ │ │ │ -358 { │ │ │ │ │ -359 │ │ │ │ │ -360 // the little trick with the default template arguments │ │ │ │ │ -361 // makes the class usable for both single-tree visitors │ │ │ │ │ -362 // and visitors for pairs of trees │ │ │ │ │ -364 template │ │ │ │ │ -_3_6_9 struct _V_i_s_i_t_C_h_i_l_d │ │ │ │ │ -370 { │ │ │ │ │ -_3_7_2 static const bool _v_a_l_u_e = false; │ │ │ │ │ -373 }; │ │ │ │ │ -374 │ │ │ │ │ -375 }; │ │ │ │ │ -376 │ │ │ │ │ -377 │ │ │ │ │ -379 │ │ │ │ │ -_3_8_3 struct _V_i_s_i_t_T_r_e_e │ │ │ │ │ -384 { │ │ │ │ │ -385 │ │ │ │ │ -386 // the little trick with the default template arguments │ │ │ │ │ -387 // makes the class usable for both single-tree visitors │ │ │ │ │ -388 // and visitors for pairs of trees │ │ │ │ │ -390 template │ │ │ │ │ -_3_9_5 struct _V_i_s_i_t_C_h_i_l_d │ │ │ │ │ -396 { │ │ │ │ │ -_3_9_8 static const bool _v_a_l_u_e = true; │ │ │ │ │ -399 }; │ │ │ │ │ -400 │ │ │ │ │ -401 }; │ │ │ │ │ -402 │ │ │ │ │ -404 │ │ │ │ │ -_4_1_1 struct _S_t_a_t_i_c_T_r_a_v_e_r_s_a_l │ │ │ │ │ -412 { │ │ │ │ │ -_4_1_4 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_:_:_f_u_l_l_y_S_t_a_t_i_c; │ │ │ │ │ -415 }; │ │ │ │ │ -416 │ │ │ │ │ -418 │ │ │ │ │ -_4_2_5 struct _D_y_n_a_m_i_c_T_r_a_v_e_r_s_a_l │ │ │ │ │ -426 { │ │ │ │ │ -_4_2_8 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; │ │ │ │ │ -429 }; │ │ │ │ │ -430 │ │ │ │ │ -_4_3_2 struct _T_r_e_e_V_i_s_i_t_o_r │ │ │ │ │ -433 : public _D_e_f_a_u_l_t_V_i_s_i_t_o_r │ │ │ │ │ -434 , public _V_i_s_i_t_T_r_e_e │ │ │ │ │ -435 {}; │ │ │ │ │ -436 │ │ │ │ │ -_4_3_8 struct _D_i_r_e_c_t_C_h_i_l_d_r_e_n_V_i_s_i_t_o_r │ │ │ │ │ -439 : public _D_e_f_a_u_l_t_V_i_s_i_t_o_r │ │ │ │ │ -440 , public _V_i_s_i_t_D_i_r_e_c_t_C_h_i_l_d_r_e_n │ │ │ │ │ -441 {}; │ │ │ │ │ -442 │ │ │ │ │ -_4_4_4 struct _T_r_e_e_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ -445 : public _D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ -446 , public _V_i_s_i_t_T_r_e_e │ │ │ │ │ -447 {}; │ │ │ │ │ -448 │ │ │ │ │ -_4_5_0 struct _D_i_r_e_c_t_C_h_i_l_d_r_e_n_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ -451 : public _D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ -452 , public _V_i_s_i_t_D_i_r_e_c_t_C_h_i_l_d_r_e_n │ │ │ │ │ -453 {}; │ │ │ │ │ -454 │ │ │ │ │ -_4_5_5 namespace Experimental::Info { │ │ │ │ │ -456 │ │ │ │ │ -_4_5_7 struct _L_e_a_f_C_o_u_n_t_e_r_V_i_s_i_t_o_r │ │ │ │ │ -458 : public _D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r │ │ │ │ │ -459 , public _S_t_a_t_i_c_T_r_a_v_e_r_s_a_l │ │ │ │ │ -460 , public _V_i_s_i_t_T_r_e_e │ │ │ │ │ -461 { │ │ │ │ │ -462 template │ │ │ │ │ -_4_6_3 auto _b_e_f_o_r_e_C_h_i_l_d(Tree&&, _C_h_i_l_d&&, TreePath, ChildIndex, U u) const { │ │ │ │ │ -464 // in this case child index is an integral constant: forward u │ │ │ │ │ -465 return u; │ │ │ │ │ -466 } │ │ │ │ │ -467 │ │ │ │ │ -468 template │ │ │ │ │ -_4_6_9 std::size_t _b_e_f_o_r_e_C_h_i_l_d(Tree&&, _C_h_i_l_d&&, TreePath, std::size_t / │ │ │ │ │ -*childIndex*/, U u) const { │ │ │ │ │ -470 // in this case child index is a run-time index: cast accumulated u to │ │ │ │ │ -std::size_t │ │ │ │ │ -471 return std::size_t{u}; │ │ │ │ │ -472 } │ │ │ │ │ -473 │ │ │ │ │ -474 template │ │ │ │ │ -_4_7_5 auto _l_e_a_f(Tree&&, TreePath, U u) const │ │ │ │ │ -476 { │ │ │ │ │ -477 return Hybrid::plus(u,Dune::Indices::_1); │ │ │ │ │ -478 } │ │ │ │ │ -479 │ │ │ │ │ -480 }; │ │ │ │ │ -481 │ │ │ │ │ -_4_8_2 struct _N_o_d_e_C_o_u_n_t_e_r_V_i_s_i_t_o_r │ │ │ │ │ -483 : public _L_e_a_f_C_o_u_n_t_e_r_V_i_s_i_t_o_r │ │ │ │ │ -484 { │ │ │ │ │ -485 template │ │ │ │ │ -_4_8_6 auto _p_r_e(Tree&&, TreePath, U u) const { │ │ │ │ │ -487 return Hybrid::plus(u,Indices::_1); │ │ │ │ │ -488 } │ │ │ │ │ -489 }; │ │ │ │ │ -490 │ │ │ │ │ -_4_9_1 struct _D_e_p_t_h_V_i_s_i_t_o_r │ │ │ │ │ -492 : public _D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r │ │ │ │ │ -493 , public _S_t_a_t_i_c_T_r_a_v_e_r_s_a_l │ │ │ │ │ -494 , public _V_i_s_i_t_T_r_e_e │ │ │ │ │ -495 { │ │ │ │ │ -496 template │ │ │ │ │ -_4_9_7 auto _l_e_a_f(Tree&&, TreePath, U u) const │ │ │ │ │ -498 { │ │ │ │ │ -499 auto path_size = index_constant<_t_r_e_e_P_a_t_h_S_i_z_e(TreePath{})>{}; │ │ │ │ │ -500 auto _d_e_p_t_h = Hybrid::plus(path_size,Indices::_1); │ │ │ │ │ -501 return Hybrid::max(_d_e_p_t_h,u); │ │ │ │ │ -502 } │ │ │ │ │ -503 }; │ │ │ │ │ -504 │ │ │ │ │ -506 // result is alwayas an integral constant │ │ │ │ │ -507 template │ │ │ │ │ -_5_0_8 auto _d_e_p_t_h(const Tree& tree) │ │ │ │ │ -509 { │ │ │ │ │ -510 return _h_y_b_r_i_d_A_p_p_l_y_T_o_T_r_e_e(tree,_D_e_p_t_h_V_i_s_i_t_o_r{},Indices::_0); │ │ │ │ │ -511 } │ │ │ │ │ -512 │ │ │ │ │ -514 // return types is std::integral_constant. │ │ │ │ │ -515 template │ │ │ │ │ -_5_1_6 constexpr auto _d_e_p_t_h() │ │ │ │ │ -517 { │ │ │ │ │ -518 return decltype(_h_y_b_r_i_d_A_p_p_l_y_T_o_T_r_e_e(std::declval(),_D_e_p_t_h_V_i_s_i_t_o_r │ │ │ │ │ -{},Indices::_0)){}; │ │ │ │ │ -519 } │ │ │ │ │ -520 │ │ │ │ │ -522 // if Tree is dynamic, return type is std::size_t, otherwise std:: │ │ │ │ │ -integral_constant. │ │ │ │ │ -523 template │ │ │ │ │ -_5_2_4 auto _n_o_d_e_C_o_u_n_t(const Tree& tree) │ │ │ │ │ -525 { │ │ │ │ │ -526 return _h_y_b_r_i_d_A_p_p_l_y_T_o_T_r_e_e(tree,_N_o_d_e_C_o_u_n_t_e_r_V_i_s_i_t_o_r{},Indices::_0); │ │ │ │ │ -527 } │ │ │ │ │ -528 │ │ │ │ │ -530 // if Tree is dynamic, return type is std::size_t, otherwise std:: │ │ │ │ │ -integral_constant. │ │ │ │ │ -531 template │ │ │ │ │ -_5_3_2 auto _l_e_a_f_C_o_u_n_t(const Tree& tree) │ │ │ │ │ -533 { │ │ │ │ │ -534 return _h_y_b_r_i_d_A_p_p_l_y_T_o_T_r_e_e(tree,_L_e_a_f_C_o_u_n_t_e_r_V_i_s_i_t_o_r{},Dune::Indices::_0); │ │ │ │ │ -535 } │ │ │ │ │ -536 │ │ │ │ │ -538 template │ │ │ │ │ -_5_3_9 constexpr bool _i_s_D_y_n_a_m_i_c = std::is_same()))>{}; │ │ │ │ │ -540 │ │ │ │ │ -541 } // namespace Experimental::Info │ │ │ │ │ -542 │ │ │ │ │ -544 │ │ │ │ │ -545 } // namespace TypeTree │ │ │ │ │ -546} //namespace Dune │ │ │ │ │ -547 │ │ │ │ │ -548#endif // DUNE_TYPETREE_VISITOR_HH │ │ │ │ │ -_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_:_:_t_r_e_e_P_a_t_h_S_i_z_e │ │ │ │ │ -constexpr std::size_t treePathSize(const HybridTreePath< T... > &) │ │ │ │ │ -Returns the size (number of components) of the given HybridTreePath. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:334 │ │ │ │ │ +338#ifdef DOXYGEN │ │ │ │ │ +339 │ │ │ │ │ +_3_4_1 _P_o_w_e_r_N_o_d_e(T& t1, T& t2, ...) │ │ │ │ │ +342 {} │ │ │ │ │ +343 │ │ │ │ │ +344#else │ │ │ │ │ +345 │ │ │ │ │ +346 template>...>::value │ │ │ │ │ +349 ,int> = 0> │ │ │ │ │ +350 _P_o_w_e_r_N_o_d_e (Children&&... children) │ │ │ │ │ +351 { │ │ │ │ │ +352 static_assert(_d_e_g_r_e_e() == sizeof...(Children), "PowerNode constructor is │ │ │ │ │ +called with incorrect number of children"); │ │ │ │ │ +353 _children = _N_o_d_e_S_t_o_r_a_g_e{convert_arg(std::forward(children))...}; │ │ │ │ │ +354 } │ │ │ │ │ +355 │ │ │ │ │ +356 template...>::value │ │ │ │ │ +359 ,int> = 0> │ │ │ │ │ +360 _P_o_w_e_r_N_o_d_e (std::shared_ptr... children) │ │ │ │ │ +361 { │ │ │ │ │ +362 static_assert(_d_e_g_r_e_e() == sizeof...(Children), "PowerNode constructor is │ │ │ │ │ +called with incorrect number of children"); │ │ │ │ │ +363 _children = _N_o_d_e_S_t_o_r_a_g_e{children...}; │ │ │ │ │ +364 } │ │ │ │ │ +365 │ │ │ │ │ +366#endif // DOXYGEN │ │ │ │ │ +367 │ │ │ │ │ +369 │ │ │ │ │ +370 private: │ │ │ │ │ +371 _N_o_d_e_S_t_o_r_a_g_e _children; │ │ │ │ │ +372 }; │ │ │ │ │ +373 │ │ │ │ │ +375 │ │ │ │ │ +376 } // namespace TypeTree │ │ │ │ │ +377} //namespace Dune │ │ │ │ │ +378 │ │ │ │ │ +379#endif // DUNE_TYPETREE_POWERNODE_HH │ │ │ │ │ +_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h │ │ │ │ │ +_t_y_p_e_t_r_a_i_t_s_._h_h │ │ │ │ │ +_u_t_i_l_i_t_y_._h_h │ │ │ │ │ +_n_o_d_e_t_a_g_s_._h_h │ │ │ │ │ +_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 │ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_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 │ │ │ │ │ -auto hybridApplyToTree(Tree &&tree, Visitor &&visitor, Init &&init) │ │ │ │ │ -Apply hybrid visitor to TypeTree. │ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:701 │ │ │ │ │ -_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_:_:_f_u_l_l_y_S_t_a_t_i_c │ │ │ │ │ -@ fullyStatic │ │ │ │ │ -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 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_i_s_D_y_n_a_m_i_c │ │ │ │ │ -constexpr bool isDynamic │ │ │ │ │ -true if any of the nodes in the tree only has dynamic degree. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:539 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_l_e_a_f_C_o_u_n_t │ │ │ │ │ -auto leafCount(const Tree &tree) │ │ │ │ │ -The number of leaf nodes in the Tree. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:532 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_n_o_d_e_C_o_u_n_t │ │ │ │ │ -auto nodeCount(const Tree &tree) │ │ │ │ │ -The total number of nodes in the Tree. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:524 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_d_e_p_t_h │ │ │ │ │ -constexpr auto depth() │ │ │ │ │ -The depth of the Tree. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:516 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_V_i_s_i_t_o_r │ │ │ │ │ -Visitor interface and base class for TypeTree visitors. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:49 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_V_i_s_i_t_o_r_:_:_i_n │ │ │ │ │ -void in(T &&, TreePath) const │ │ │ │ │ -Method for infix tree traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:72 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_V_i_s_i_t_o_r_:_:_a_f_t_e_r_C_h_i_l_d │ │ │ │ │ -void afterChild(T &&, Child &&, TreePath, ChildIndex) const │ │ │ │ │ -Method for child-parent traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:122 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_V_i_s_i_t_o_r_:_:_b_e_f_o_r_e_C_h_i_l_d │ │ │ │ │ -void beforeChild(T &&, Child &&, TreePath, ChildIndex) const │ │ │ │ │ -Method for parent-child traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:107 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_V_i_s_i_t_o_r_:_:_p_o_s_t │ │ │ │ │ -void post(T &&, TreePath) const │ │ │ │ │ -Method for postfix tree traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:83 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_V_i_s_i_t_o_r_:_:_l_e_a_f │ │ │ │ │ -void leaf(T &&, TreePath) const │ │ │ │ │ -Method for leaf traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:93 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_V_i_s_i_t_o_r_:_:_p_r_e │ │ │ │ │ -void pre(T &&, TreePath) const │ │ │ │ │ -Method for prefix tree traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:60 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ -Visitor interface and base class for visitors of pairs of TypeTrees. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:164 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r_:_:_l_e_a_f │ │ │ │ │ -void leaf(T1 &&, T2 &&, TreePath) const │ │ │ │ │ -Method for leaf traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:216 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r_:_:_b_e_f_o_r_e_C_h_i_l_d │ │ │ │ │ -void beforeChild(T1 &&, Child1 &&, T2 &&, Child2 &&, TreePath, ChildIndex) │ │ │ │ │ -const │ │ │ │ │ -Method for parent-child traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:232 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r_:_:_p_r_e │ │ │ │ │ -void pre(T1 &&, T2 &&, TreePath) const │ │ │ │ │ -Method for prefix tree traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:176 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r_:_:_p_o_s_t │ │ │ │ │ -void post(T1 &&, T2 &&, TreePath) const │ │ │ │ │ -Method for postfix traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:201 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r_:_:_i_n │ │ │ │ │ -void in(T1 &&, T2 &&, TreePath) const │ │ │ │ │ -Method for infix tree traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:189 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r_:_:_a_f_t_e_r_C_h_i_l_d │ │ │ │ │ -void afterChild(T1 &&, Child1 &&, T2 &&, Child2 &&, TreePath, ChildIndex) const │ │ │ │ │ -Method for child-parent traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:248 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r │ │ │ │ │ -Hybrid visitor interface and base class for TypeTree hybrid visitors. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:286 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r_:_:_p_o_s_t │ │ │ │ │ -auto post(T &&, TreePath, const U &u) const │ │ │ │ │ -Method for postfix tree traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:316 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r_:_:_p_r_e │ │ │ │ │ -auto pre(T &&, TreePath, const U &u) const │ │ │ │ │ -Method for prefix tree traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:296 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r_:_:_l_e_a_f │ │ │ │ │ -auto leaf(T &&, TreePath, const U &u) const │ │ │ │ │ -Method for leaf traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:326 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r_:_:_a_f_t_e_r_C_h_i_l_d │ │ │ │ │ -auto afterChild(T &&, Child &&, TreePath, ChildIndex, const U &u) const │ │ │ │ │ -Method for child-parent traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:346 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r_:_:_i_n │ │ │ │ │ -auto in(T &&, TreePath, const U &u) const │ │ │ │ │ -Method for infix tree traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:306 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r_:_:_b_e_f_o_r_e_C_h_i_l_d │ │ │ │ │ -auto beforeChild(T &&, Child &&, TreePath, ChildIndex, const U &u) const │ │ │ │ │ -Method for parent-child traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:336 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_D_i_r_e_c_t_C_h_i_l_d_r_e_n │ │ │ │ │ -Mixin base class for visitors that only want to visit the direct children of a │ │ │ │ │ -node. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:358 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_D_i_r_e_c_t_C_h_i_l_d_r_e_n_:_:_V_i_s_i_t_C_h_i_l_d │ │ │ │ │ -Template struct for determining whether or not to visit a given child. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:370 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_D_i_r_e_c_t_C_h_i_l_d_r_e_n_:_:_V_i_s_i_t_C_h_i_l_d_:_:_v_a_l_u_e │ │ │ │ │ -static const bool value │ │ │ │ │ -Do not visit any child. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:372 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_T_r_e_e │ │ │ │ │ -Mixin base class for visitors that want to visit the complete tree. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:384 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_T_r_e_e_:_:_V_i_s_i_t_C_h_i_l_d │ │ │ │ │ -Template struct for determining whether or not to visit a given child. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:396 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_T_r_e_e_:_:_V_i_s_i_t_C_h_i_l_d_:_:_v_a_l_u_e │ │ │ │ │ -static const bool value │ │ │ │ │ -Visit any child. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:398 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_T_r_a_v_e_r_s_a_l │ │ │ │ │ -Mixin base class for visitors that require a static TreePath during traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:412 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_T_r_a_v_e_r_s_a_l_:_:_t_r_e_e_P_a_t_h_T_y_p_e │ │ │ │ │ -static const TreePathType::Type treePathType │ │ │ │ │ -Use the static tree traversal algorithm. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:414 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_T_r_a_v_e_r_s_a_l │ │ │ │ │ -Mixin base class for visitors that only need a dynamic TreePath during │ │ │ │ │ -traversal. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:426 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_T_r_a_v_e_r_s_a_l_:_:_t_r_e_e_P_a_t_h_T_y_p_e │ │ │ │ │ -static const TreePathType::Type treePathType │ │ │ │ │ -Use the dynamic tree traversal algorithm. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:428 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_V_i_s_i_t_o_r │ │ │ │ │ -Convenience base class for visiting the entire tree. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:435 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_i_r_e_c_t_C_h_i_l_d_r_e_n_V_i_s_i_t_o_r │ │ │ │ │ -Convenience base class for visiting the direct children of a node. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:441 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ -Convenience base class for visiting an entire tree pair. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:447 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_i_r_e_c_t_C_h_i_l_d_r_e_n_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ -Convenience base class for visiting the direct children of a node pair. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:453 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_L_e_a_f_C_o_u_n_t_e_r_V_i_s_i_t_o_r │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:461 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_L_e_a_f_C_o_u_n_t_e_r_V_i_s_i_t_o_r_:_:_l_e_a_f │ │ │ │ │ -auto leaf(Tree &&, TreePath, U u) const │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:475 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_L_e_a_f_C_o_u_n_t_e_r_V_i_s_i_t_o_r_:_:_b_e_f_o_r_e_C_h_i_l_d │ │ │ │ │ -auto beforeChild(Tree &&, Child &&, TreePath, ChildIndex, U u) const │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:463 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_L_e_a_f_C_o_u_n_t_e_r_V_i_s_i_t_o_r_:_:_b_e_f_o_r_e_C_h_i_l_d │ │ │ │ │ -std::size_t beforeChild(Tree &&, Child &&, TreePath, std::size_t, U u) const │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:469 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_N_o_d_e_C_o_u_n_t_e_r_V_i_s_i_t_o_r │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:484 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_N_o_d_e_C_o_u_n_t_e_r_V_i_s_i_t_o_r_:_:_p_r_e │ │ │ │ │ -auto pre(Tree &&, TreePath, U u) const │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:486 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_D_e_p_t_h_V_i_s_i_t_o_r │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:495 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_D_e_p_t_h_V_i_s_i_t_o_r_:_:_l_e_a_f │ │ │ │ │ -auto leaf(Tree &&, TreePath, U u) const │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:497 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_T_a_g │ │ │ │ │ +Tag designating a power node. │ │ │ │ │ +DDeeffiinniittiioonn nodetags.hh:21 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e │ │ │ │ │ +Collect k instances of type T within a dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:52 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ +void setChild(T &t, index_constant< i >={}) │ │ │ │ │ +Sets the i-th child to the passed-in value. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:143 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ +T & child(std::size_t i) │ │ │ │ │ +Returns the i-th child. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:175 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ +const T & child(index_constant< i >={}) const │ │ │ │ │ +Returns the i-th child (const version). │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:113 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ +void setChild(std::shared_ptr< T > st, index_constant< i >={}) │ │ │ │ │ +Sets the stored value representing the i-th child to the passed-in value. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:159 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ +std::shared_ptr< T > childStorage(index_constant< i >={}) │ │ │ │ │ +Returns the storage of the i-th child. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:124 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_P_o_w_e_r_N_o_d_e │ │ │ │ │ +PowerNode(T &t1, T &t2,...) │ │ │ │ │ +Initialize all children with the passed-in objects. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:341 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_n_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ +const NodeStorage & nodeStorage() const │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:232 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ +std::array< std::shared_ptr< T >, k > NodeStorage │ │ │ │ │ +The type used for storing the children. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:77 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ +std::shared_ptr< const T > childStorage(index_constant< i >={}) const │ │ │ │ │ +Returns the storage of the i-th child (const version). │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:135 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_P_o_w_e_r_N_o_d_e │ │ │ │ │ +PowerNode(T &t, bool distinct_objects=true) │ │ │ │ │ +Initialize all children with copies of a storage object constructed from the │ │ │ │ │ +parameter t. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:324 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_N_o_d_e_T_a_g │ │ │ │ │ +PowerNodeTag NodeTag │ │ │ │ │ +The type tag that describes a PowerNode. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:71 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ +const T & child(std::size_t i) const │ │ │ │ │ +Returns the i-th child (const version). │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:185 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_d_e_g_r_e_e │ │ │ │ │ +static constexpr auto degree() │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:65 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ +std::shared_ptr< const T > childStorage(std::size_t i) const │ │ │ │ │ +Returns the storage of the i-th child (const version). │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:205 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ +void setChild(std::size_t i, std::shared_ptr< T > st) │ │ │ │ │ +Sets the stored value representing the i-th child to the passed-in value. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:226 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_i_s_C_o_m_p_o_s_i_t_e │ │ │ │ │ +static const bool isComposite │ │ │ │ │ +Mark this class as a non composite in the dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:63 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_i_s_L_e_a_f │ │ │ │ │ +static const bool isLeaf │ │ │ │ │ +Mark this class as non leaf in the dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:57 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_i_s_P_o_w_e_r │ │ │ │ │ +static const bool isPower │ │ │ │ │ +Mark this class as a power in the dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:60 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_P_o_w_e_r_N_o_d_e │ │ │ │ │ +PowerNode(const NodeStorage &children) │ │ │ │ │ +Initialize the PowerNode with a copy of the passed-in storage type. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:319 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_C_h_i_l_d_T_y_p_e │ │ │ │ │ +T ChildType │ │ │ │ │ +The type of each child. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:74 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ +T & child(index_constant< i >={}) │ │ │ │ │ +Returns the i-th child. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:102 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ +ImplementationDefined & child(Indices... indices) │ │ │ │ │ +Returns the child given by the list of indices. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:266 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ +void setChild(std::size_t i, T &&t) │ │ │ │ │ +Store the passed value in i-th child. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:219 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ +void setChild(T &&t, index_constant< i >={}) │ │ │ │ │ +Store the passed value in i-th child. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:151 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_P_o_w_e_r_N_o_d_e │ │ │ │ │ +PowerNode() │ │ │ │ │ +Default constructor. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:315 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ +const ImplementationDefined & child(Indices... indices) │ │ │ │ │ +Returns the child given by the list of indices. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:286 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ +void setChild(std::size_t i, T &t) │ │ │ │ │ +Sets the i-th child to the passed-in value. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:212 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ +std::shared_ptr< T > childStorage(std::size_t i) │ │ │ │ │ +Returns the storage of the i-th child. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:195 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_C_h_i_l_d │ │ │ │ │ +Access to the type and storage type of the i-th child. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:83 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_C_h_i_l_d_:_:_t_y_p_e │ │ │ │ │ +T type │ │ │ │ │ +The type of the child. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:91 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_C_h_i_l_d_:_:_T_y_p_e │ │ │ │ │ +T Type │ │ │ │ │ +The type of the child. │ │ │ │ │ +DDeeffiinniittiioonn powernode.hh:88 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_I_s_T_r_e_e_P_a_t_h │ │ │ │ │ +Check if type represents a tree path. │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:184 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00014.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: treecontainer.hh File Reference │ │ │ │ +dune-typetree: typetraits.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -72,73 +72,99 @@ │ │ │ │
  • dune
  • typetree
    • │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ Classes | │ │ │ │ Namespaces | │ │ │ │ -Typedefs | │ │ │ │ Functions
    │ │ │ │ -
    treecontainer.hh File Reference
    │ │ │ │ +
    typetraits.hh File Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │
    #include <type_traits>
    │ │ │ │ -#include <utility>
    │ │ │ │ -#include <functional>
    │ │ │ │ -#include <array>
    │ │ │ │ -#include <dune/common/indices.hh>
    │ │ │ │ -#include <dune/common/hybridutilities.hh>
    │ │ │ │ -#include <dune/common/rangeutilities.hh>
    │ │ │ │ -#include <dune/common/tuplevector.hh>
    │ │ │ │ -#include <dune/typetree/treepath.hh>
    │ │ │ │ +#include <dune/common/typetraits.hh>
    │ │ │ │ +#include <dune/typetree/treepath.hh>
    │ │ │ │ +#include <dune/typetree/nodeinterface.hh>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    class  Dune::TypeTree::Detail::ContainerFactory< LeafToValue >
    struct  Dune::first_type< T0, T... >
     
    class  Dune::TypeTree::Detail::TreeContainerVectorBackend< Container >
    struct  Dune::TypeTree::has_node_tag< T >
     
    struct  Dune::TypeTree::Detail::LeafToDefaultConstructibleValue< LeafToValue >
    struct  Dune::TypeTree::has_node_tag< T >::yes
     
    struct  Dune::TypeTree::has_node_tag< T >::no
     
    struct  Dune::TypeTree::has_node_tag_value< T, V >
     
    struct  Dune::TypeTree::has_node_tag_value< T, V >::maybe< N >
     
    struct  Dune::TypeTree::has_node_tag_value< T, V >::yes
     
    struct  Dune::TypeTree::has_node_tag_value< T, V >::no
     
    struct  Dune::TypeTree::has_implementation_tag< T >
     
    struct  Dune::TypeTree::has_implementation_tag< T >::yes
     
    struct  Dune::TypeTree::has_implementation_tag< T >::no
     
    struct  Dune::TypeTree::has_implementation_tag_value< T, V >
     
    struct  Dune::TypeTree::has_implementation_tag_value< T, V >::maybe< N >
     
    struct  Dune::TypeTree::has_implementation_tag_value< T, V >::yes
     
    struct  Dune::TypeTree::has_implementation_tag_value< T, V >::no
     
    struct  Dune::TypeTree::AlwaysVoid< typename >
     
    struct  Dune::TypeTree::meta_function
     Marker tag declaring a meta function. More...
     
    struct  Dune::TypeTree::lazy_evaluate< F >
     Helper meta function to delay evaluation of F. More...
     
    struct  Dune::TypeTree::lazy_identity< F >
     Identity function. More...
     
    struct  Dune::TypeTree::evaluate_if_meta_function< F >
     Meta function that evaluates its argument iff it inherits from meta_function. More...
     
    struct  Dune::TypeTree::IsTreePath< T >
     Check if type represents a tree path. More...
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
     
    namespace  Dune::TypeTree::Detail
    namespace  Dune::TypeTree::impl
     
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -

    │ │ │ │ -Typedefs

    template<class Value , class Tree >
    using Dune::TypeTree::UniformTreeContainer = std::decay_t< decltype(makeTreeContainer< Value >(std::declval< const Tree & >()))>
     Alias to container type generated by makeTreeContainer for given tree type and uniform value type.
     
    template<template< class Node > class LeafToValue, class Tree >
    using Dune::TypeTree::TreeContainer = std::decay_t< decltype(makeTreeContainer(std::declval< const Tree & >(), std::declval< Detail::LeafToDefaultConstructibleValue< LeafToValue > >()))>
     Alias to container type generated by makeTreeContainer for give tree type and when using LeafToValue to create values.
     
    │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │

    │ │ │ │ Functions

    template<class Container >
    auto Dune::TypeTree::Detail::makeTreeContainerVectorBackend (Container &&container)
     
    template<class Tree , class LeafToValue >
    auto Dune::TypeTree::makeTreeContainer (const Tree &tree, LeafToValue &&leafToValue)
     Create container havin the same structure as the given tree.
     
    template<class Value , class Tree >
    auto Dune::TypeTree::makeTreeContainer (const Tree &tree)
     Create container havin the same structure as the given tree.
     
    template<typename T >
    T * Dune::TypeTree::declptr ()
     Helper function for generating a pointer to a value of type T in an unevaluated operand setting.
     
    constexpr auto Dune::TypeTree::impl::isTreePath (void *) -> std::false_type
     
    template<class... I>
    constexpr auto Dune::TypeTree::impl::isTreePath (const HybridTreePath< I... > *) -> std::true_type
     
    template<class T >
    constexpr auto Dune::TypeTree::isTreePath (const T &) -> IsTreePath< T >
     Check if given object represents a tree path.
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,62 +1,87 @@ │ │ │ │ │ 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 | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s │ │ │ │ │ -treecontainer.hh File Reference │ │ │ │ │ +_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 │ │ │ │ │ +typetraits.hh File Reference │ │ │ │ │ #include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ +#include │ │ │ │ │ #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_/_n_o_d_e_i_n_t_e_r_f_a_c_e_._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 │ │ │ │ │ - class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_C_o_n_t_a_i_n_e_r_F_a_c_t_o_r_y_<_ _L_e_a_f_T_o_V_a_l_u_e_ _> │ │ │ │ │ +struct   _D_u_n_e_:_:_f_i_r_s_t___t_y_p_e_<_ _T_0_,_ _T_._._._ _> │ │ │ │ │   │ │ │ │ │ - class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d_<_ _C_o_n_t_a_i_n_e_r_ _> │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_<_ _T_ _> │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_L_e_a_f_T_o_D_e_f_a_u_l_t_C_o_n_s_t_r_u_c_t_i_b_l_e_V_a_l_u_e_<_ _L_e_a_f_T_o_V_a_l_u_e_ _> │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_<_ _T_ _>_:_:_y_e_s │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_<_ _T_ _>_:_:_n_o │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_<_ _T_,_ _V_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_<_ _T_,_ _V_ _>_:_:_m_a_y_b_e_<_ _N_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_<_ _T_,_ _V_ _>_:_:_y_e_s │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_<_ _T_,_ _V_ _>_:_:_n_o │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_<_ _T_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_<_ _T_ _>_:_:_y_e_s │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_<_ _T_ _>_:_:_n_o │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_<_ _T_,_ _V_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_<_ _T_,_ _V_ _>_:_:_m_a_y_b_e_<_ _N_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_<_ _T_,_ _V_ _>_:_:_y_e_s │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_<_ _T_,_ _V_ _>_:_:_n_o │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_l_w_a_y_s_V_o_i_d_<_ _t_y_p_e_n_a_m_e_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_e_t_a___f_u_n_c_t_i_o_n │ │ │ │ │ +  Marker tag declaring a meta function. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_l_a_z_y___e_v_a_l_u_a_t_e_<_ _F_ _> │ │ │ │ │ +  Helper meta function to delay evaluation of F. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_l_a_z_y___i_d_e_n_t_i_t_y_<_ _F_ _> │ │ │ │ │ +  Identity function. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_e_v_a_l_u_a_t_e___i_f___m_e_t_a___f_u_n_c_t_i_o_n_<_ _F_ _> │ │ │ │ │ +  Meta function that evaluates its argument iff it inherits from │ │ │ │ │ + _m_e_t_a___f_u_n_c_t_i_o_n. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_I_s_T_r_e_e_P_a_t_h_<_ _T_ _> │ │ │ │ │ +  Check if type represents a tree path. _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_:_:_D_e_t_a_i_l │ │ │ │ │ -  │ │ │ │ │ -TTyyppeeddeeffss │ │ │ │ │ -template │ │ │ │ │ -using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_U_n_i_f_o_r_m_T_r_e_e_C_o_n_t_a_i_n_e_r = std::decay_t< decltype │ │ │ │ │ - (_m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r< Value >(std::declval< const Tree & >()))> │ │ │ │ │ -  Alias to container type generated by makeTreeContainer for given tree │ │ │ │ │ - type and uniform value type. │ │ │ │ │ -  │ │ │ │ │ -template class LeafToValue, class Tree > │ │ │ │ │ -using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r = std::decay_t< decltype(_m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r │ │ │ │ │ - (std::declval< const Tree & >(), std::declval< _D_e_t_a_i_l_:_: │ │ │ │ │ - _L_e_a_f_T_o_D_e_f_a_u_l_t_C_o_n_s_t_r_u_c_t_i_b_l_e_V_a_l_u_e< LeafToValue > >()))> │ │ │ │ │ -  Alias to container type generated by makeTreeContainer for give tree │ │ │ │ │ - type and when using LeafToValue to create values. │ │ │ │ │ +namespace   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_m_p_l │ │ │ │ │   │ │ │ │ │ FFuunnccttiioonnss │ │ │ │ │ -template │ │ │ │ │ -auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d (Container │ │ │ │ │ - &&container) │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ -auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r (const Tree &tree, LeafToValue │ │ │ │ │ - &&leafToValue) │ │ │ │ │ -  Create container havin the same structure as the given tree. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ -auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r (const Tree &tree) │ │ │ │ │ -  Create container havin the same structure as the given tree. │ │ │ │ │ +template │ │ │ │ │ + T *  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_d_e_c_l_p_t_r () │ │ │ │ │ +  Helper function for generating a pointer to a value of type T │ │ │ │ │ + in an unevaluated operand setting. │ │ │ │ │ +  │ │ │ │ │ +constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_m_p_l_:_:_i_s_T_r_e_e_P_a_t_h (void *) -> std::false_type │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ +constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_m_p_l_:_:_i_s_T_r_e_e_P_a_t_h (const _H_y_b_r_i_d_T_r_e_e_P_a_t_h< I... > │ │ │ │ │ + *) -> std::true_type │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ +constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_s_T_r_e_e_P_a_t_h (const T &) -> _I_s_T_r_e_e_P_a_t_h< T > │ │ │ │ │ +  Check if given object represents a tree path. │ │ │ │ │   │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00014_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: treecontainer.hh Source File │ │ │ │ +dune-typetree: typetraits.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,333 +74,278 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ -
    treecontainer.hh
    │ │ │ │ +
    typetraits.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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_TREECONTAINER_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_TREECONTAINER_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_TYPETRAITS_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_TYPETRAITS_HH
    │ │ │ │
    8
    │ │ │ │
    9#include <type_traits>
    │ │ │ │ -
    10#include <utility>
    │ │ │ │ -
    11#include <functional>
    │ │ │ │ -
    12#include <array>
    │ │ │ │ -
    13
    │ │ │ │ -
    14#include <dune/common/indices.hh>
    │ │ │ │ -
    15#include <dune/common/hybridutilities.hh>
    │ │ │ │ -
    16#include <dune/common/rangeutilities.hh>
    │ │ │ │ -
    17#include <dune/common/tuplevector.hh>
    │ │ │ │ -
    18
    │ │ │ │ -
    19#include <dune/typetree/treepath.hh>
    │ │ │ │ -
    20
    │ │ │ │ -
    21namespace Dune {
    │ │ │ │ -
    22 namespace TypeTree {
    │ │ │ │ -
    23
    │ │ │ │ -
    24 namespace Detail {
    │ │ │ │ -
    25
    │ │ │ │ -
    26 /*
    │ │ │ │ -
    27 * \brief A factory class creating a hybrid container compatible with a type tree
    │ │ │ │ -
    28 *
    │ │ │ │ -
    29 * This class allows to create a nested hybrid container having the same structure
    │ │ │ │ -
    30 * as a given type tree. Power nodes are represented as std::array's while composite
    │ │ │ │ -
    31 * nodes are represented as Dune::TupleVector's. The stored values for the leaf nodes
    │ │ │ │ -
    32 * are creating using a given predicate. Once created, the factory provides an
    │ │ │ │ -
    33 * operator() creating the container for the tree given as argument.
    │ │ │ │ -
    34 *
    │ │ │ │ -
    35 * \tparam LeafToValue Type of a predicate that determines the stored values at the leafs
    │ │ │ │ -
    36 */
    │ │ │ │ -
    37 template<class LeafToValue>
    │ │ │ │ -
    │ │ │ │ -
    38 class ContainerFactory
    │ │ │ │ -
    39 {
    │ │ │ │ -
    40 template<class N>
    │ │ │ │ -
    41 using DynamicDegreeConcept = decltype((std::size_t(std::declval<N>().degree()), true));
    │ │ │ │ -
    42
    │ │ │ │ -
    43 template<class N>
    │ │ │ │ -
    44 using StaticDegreeConcept = decltype((std::integral_constant<std::size_t, N::degree()>{}, true));
    │ │ │ │ -
    45
    │ │ │ │ -
    46 template<class N>
    │ │ │ │ -
    47 using DynamicChildAccessConcept = decltype((std::declval<N>().child(0u), true));
    │ │ │ │ -
    48
    │ │ │ │ -
    49 public:
    │ │ │ │ -
    50
    │ │ │ │ -
    │ │ │ │ -
    58 ContainerFactory(LeafToValue leafToValue) :
    │ │ │ │ -
    59 leafToValue_(leafToValue)
    │ │ │ │ -
    60 {}
    │ │ │ │ -
    │ │ │ │ -
    61
    │ │ │ │ -
    62 template<class Node>
    │ │ │ │ -
    │ │ │ │ -
    63 auto operator()(const Node& node)
    │ │ │ │ -
    64 {
    │ │ │ │ -
    65 return (*this)(node, Dune::PriorityTag<5>{});
    │ │ │ │ -
    66 }
    │ │ │ │ +
    10#include <dune/common/typetraits.hh>
    │ │ │ │ +
    11
    │ │ │ │ +
    12#include <dune/typetree/treepath.hh>
    │ │ │ │ +
    13#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ +
    14
    │ │ │ │ +
    15namespace Dune {
    │ │ │ │ +
    16
    │ │ │ │ +
    17 // Provide some more C++11 TMP helpers.
    │ │ │ │ +
    18 // These should be upstreamed to dune-common ASAP.
    │ │ │ │ +
    19
    │ │ │ │ +
    20 template<typename... T>
    │ │ │ │ +
    21 struct first_type;
    │ │ │ │ +
    22
    │ │ │ │ +
    23 template<typename T0, typename... T>
    │ │ │ │ +
    │ │ │ │ +
    24 struct first_type<T0,T...>
    │ │ │ │ +
    25 {
    │ │ │ │ +
    26 typedef T0 type;
    │ │ │ │ +
    27 };
    │ │ │ │ +
    │ │ │ │ +
    28
    │ │ │ │ +
    29 namespace TypeTree {
    │ │ │ │ +
    30
    │ │ │ │ +
    31 template<typename T>
    │ │ │ │ +
    │ │ │ │ +
    32 struct has_node_tag
    │ │ │ │ +
    33 {
    │ │ │ │ +
    34 struct yes { char dummy[1]; };
    │ │ │ │ +
    35 struct no { char dummy[2]; };
    │ │ │ │ +
    36
    │ │ │ │ +
    37 template<typename X>
    │ │ │ │ +
    38 static yes test(NodeTag<X> *);
    │ │ │ │ +
    39 template<typename X>
    │ │ │ │ +
    40 static no test(...);
    │ │ │ │ +
    41
    │ │ │ │ +
    43 constexpr static bool value = sizeof(test<T>(0)) == sizeof(yes);
    │ │ │ │ +
    44 };
    │ │ │ │
    │ │ │ │ -
    67
    │ │ │ │ -
    68 private:
    │ │ │ │ +
    45
    │ │ │ │ +
    46 template<typename T, typename V>
    │ │ │ │ +
    │ │ │ │ +
    47 struct has_node_tag_value
    │ │ │ │ +
    48 {
    │ │ │ │ +
    49 template<int N>
    │ │ │ │ +
    50 struct maybe { char dummy[N+1]; };
    │ │ │ │ +
    51 struct yes { char dummy[2]; };
    │ │ │ │ +
    52 struct no { char dummy[1]; };
    │ │ │ │ +
    53
    │ │ │ │ +
    54 template<typename X>
    │ │ │ │ +
    55 static maybe<std::is_base_of<V, NodeTag<X>>::value>
    │ │ │ │ +
    56 test(NodeTag<X> * a);
    │ │ │ │ +
    57 template<typename X>
    │ │ │ │ +
    58 static no test(...);
    │ │ │ │ +
    59
    │ │ │ │ +
    61 constexpr static bool value = sizeof(test<T>(0)) == sizeof(yes);
    │ │ │ │ +
    62 };
    │ │ │ │ +
    │ │ │ │ +
    63
    │ │ │ │ +
    64 template<typename T>
    │ │ │ │ +
    │ │ │ │ +
    65 struct has_implementation_tag
    │ │ │ │ +
    66 {
    │ │ │ │ +
    67 struct yes { char dummy[1]; };
    │ │ │ │ +
    68 struct no { char dummy[2]; };
    │ │ │ │
    69
    │ │ │ │ -
    70 template<class Node,
    │ │ │ │ -
    71 std::enable_if_t<Node::isLeaf, bool> = true>
    │ │ │ │ -
    72 auto operator()(const Node& node, Dune::PriorityTag<4>)
    │ │ │ │ -
    73 {
    │ │ │ │ -
    74 return leafToValue_(node);
    │ │ │ │ -
    75 }
    │ │ │ │ -
    76
    │ │ │ │ -
    77 template<class Node,
    │ │ │ │ -
    78 StaticDegreeConcept<Node> = true,
    │ │ │ │ -
    79 DynamicChildAccessConcept<Node> = true>
    │ │ │ │ -
    80 auto operator()(const Node& node, Dune::PriorityTag<3>)
    │ │ │ │ -
    81 {
    │ │ │ │ -
    82 return Dune::unpackIntegerSequence([&](auto... indices) {
    │ │ │ │ -
    83 return std::array{(*this)(node.child(indices))...};
    │ │ │ │ -
    84 }, std::make_index_sequence<std::size_t(Node::degree())>());
    │ │ │ │ -
    85 }
    │ │ │ │ +
    70 template<typename X>
    │ │ │ │ +
    71 static yes test(ImplementationTag<X> *);
    │ │ │ │ +
    72 template<typename X>
    │ │ │ │ +
    73 static no test(...);
    │ │ │ │ +
    74
    │ │ │ │ +
    76 constexpr static bool value = sizeof(test<T>(0)) == sizeof(yes);
    │ │ │ │ +
    77 };
    │ │ │ │ +
    │ │ │ │ +
    78
    │ │ │ │ +
    79 template<typename T, typename V>
    │ │ │ │ +
    │ │ │ │ +
    80 struct has_implementation_tag_value
    │ │ │ │ +
    81 {
    │ │ │ │ +
    82 template<int N>
    │ │ │ │ +
    83 struct maybe { char dummy[N+1]; };
    │ │ │ │ +
    84 struct yes { char dummy[2]; };
    │ │ │ │ +
    85 struct no { char dummy[1]; };
    │ │ │ │
    86
    │ │ │ │ -
    87 template<class Node,
    │ │ │ │ -
    88 DynamicDegreeConcept<Node> = true,
    │ │ │ │ -
    89 DynamicChildAccessConcept<Node> = true>
    │ │ │ │ -
    90 auto operator()(const Node& node, Dune::PriorityTag<2>)
    │ │ │ │ -
    91 {
    │ │ │ │ -
    92 using TransformedChild = decltype((*this)(node.child(0)));
    │ │ │ │ -
    93 std::vector<TransformedChild> container;
    │ │ │ │ -
    94 container.reserve(node.degree());
    │ │ │ │ -
    95 for (std::size_t i = 0; i < node.degree(); ++i)
    │ │ │ │ -
    96 container.emplace_back((*this)(node.child(i)));
    │ │ │ │ -
    97 return container;
    │ │ │ │ -
    98 }
    │ │ │ │ -
    99
    │ │ │ │ -
    100 template<class Node,
    │ │ │ │ -
    101 StaticDegreeConcept<Node> = true>
    │ │ │ │ -
    102 auto operator()(const Node& node, Dune::PriorityTag<1>)
    │ │ │ │ -
    103 {
    │ │ │ │ -
    104 return Dune::unpackIntegerSequence([&](auto... indices) {
    │ │ │ │ -
    105 return Dune::makeTupleVector((*this)(node.child(indices))...);
    │ │ │ │ -
    106 }, std::make_index_sequence<std::size_t(Node::degree())>());
    │ │ │ │ -
    107 }
    │ │ │ │ +
    87 template<typename X>
    │ │ │ │ +
    88 static maybe<std::is_base_of<V, ImplementationTag<X>>::value>
    │ │ │ │ +
    89 test(ImplementationTag<X> * a);
    │ │ │ │ +
    90 template<typename X>
    │ │ │ │ +
    91 static no test(...);
    │ │ │ │ +
    92
    │ │ │ │ +
    94 constexpr static bool value = sizeof(test<T>(0)) == sizeof(yes);
    │ │ │ │ +
    95 };
    │ │ │ │ +
    │ │ │ │ +
    96
    │ │ │ │ +
    97 template<typename>
    │ │ │ │ +
    │ │ │ │ +
    98 struct AlwaysVoid
    │ │ │ │ +
    99 {
    │ │ │ │ +
    100 typedef void type;
    │ │ │ │ +
    101 };
    │ │ │ │ +
    │ │ │ │ +
    102
    │ │ │ │ +
    103
    │ │ │ │ +
    105 template<typename T>
    │ │ │ │ +
    106 T* declptr();
    │ │ │ │ +
    107
    │ │ │ │
    108
    │ │ │ │ -
    109 private:
    │ │ │ │ -
    110 LeafToValue leafToValue_;
    │ │ │ │ -
    111 };
    │ │ │ │ -
    │ │ │ │ -
    112
    │ │ │ │ -
    113
    │ │ │ │ -
    114 /*
    │ │ │ │ -
    115 * \brief Wrap nested container to provide a VectorBackend
    │ │ │ │ -
    116 */
    │ │ │ │ -
    117 template<class Container>
    │ │ │ │ -
    │ │ │ │ -
    118 class TreeContainerVectorBackend
    │ │ │ │ -
    119 {
    │ │ │ │ -
    120 template<class C>
    │ │ │ │ -
    121 static constexpr decltype(auto) accessByTreePath(C&& container, const HybridTreePath<>& path)
    │ │ │ │ -
    122 {
    │ │ │ │ -
    123 return container;
    │ │ │ │ -
    124 }
    │ │ │ │ -
    125
    │ │ │ │ -
    126 template<class C, class... T>
    │ │ │ │ -
    127 static constexpr decltype(auto) accessByTreePath(C&& container, const HybridTreePath<T...>& path)
    │ │ │ │ -
    128 {
    │ │ │ │ -
    129 auto head = path[Dune::Indices::_0];
    │ │ │ │ -
    130 auto tailPath = Dune::unpackIntegerSequence([&](auto... i){
    │ │ │ │ -
    131 return treePath(path[Dune::index_constant<i+1>{}]...);
    │ │ │ │ -
    132 }, std::make_index_sequence<sizeof...(T)-1>());
    │ │ │ │ -
    133 return accessByTreePath(container[head], tailPath);
    │ │ │ │ -
    134 }
    │ │ │ │ -
    135
    │ │ │ │ -
    136 template<class C, class Tree,
    │ │ │ │ -
    137 std::enable_if_t<Tree::isLeaf, bool> = true>
    │ │ │ │ -
    138 static void resizeImpl(C& /*container*/, const Tree& /*tree*/, Dune::PriorityTag<2>)
    │ │ │ │ -
    139 {
    │ │ │ │ -
    140 /* do nothing */
    │ │ │ │ -
    141 }
    │ │ │ │ -
    142
    │ │ │ │ -
    143 template<class C, class Tree,
    │ │ │ │ -
    144 class = decltype(std::declval<C>().resize(0u))>
    │ │ │ │ -
    145 static void resizeImpl(C& container, const Tree& tree, Dune::PriorityTag<1>)
    │ │ │ │ -
    146 {
    │ │ │ │ -
    147 container.resize(tree.degree());
    │ │ │ │ -
    148 Dune::Hybrid::forEach(Dune::range(tree.degree()), [&](auto i) {
    │ │ │ │ -
    149 resizeImpl(container[i], tree.child(i), Dune::PriorityTag<5>{});
    │ │ │ │ -
    150 });
    │ │ │ │ -
    151 }
    │ │ │ │ -
    152
    │ │ │ │ -
    153 template<class C, class Tree>
    │ │ │ │ -
    154 static void resizeImpl(C& container, const Tree& tree, Dune::PriorityTag<0>)
    │ │ │ │ -
    155 {
    │ │ │ │ -
    156 Dune::Hybrid::forEach(Dune::range(tree.degree()), [&](auto i) {
    │ │ │ │ -
    157 resizeImpl(container[i], tree.child(i), Dune::PriorityTag<5>{});
    │ │ │ │ -
    158 });
    │ │ │ │ -
    159 }
    │ │ │ │ +
    109 // Support for lazy evaluation of meta functions. This is required when doing
    │ │ │ │ +
    110 // nested tag dispatch without C++11-style typedefs (based on using syntax).
    │ │ │ │ +
    111 // The standard struct-based meta functions cause premature evaluation in a
    │ │ │ │ +
    112 // context that is not SFINAE-compatible. We thus have to return the meta function
    │ │ │ │ +
    113 // without evaluating it, placing that burden on the caller. On the other hand,
    │ │ │ │ +
    114 // the lookup will often directly be the target type, so here is some helper code
    │ │ │ │ +
    115 // to automatically do the additional evaluation if necessary.
    │ │ │ │ +
    116 // Too bad that the new syntax is GCC 4.6+...
    │ │ │ │ +
    117
    │ │ │ │ +
    118
    │ │ │ │ +
    120
    │ │ │ │ +
    123 struct meta_function {};
    │ │ │ │ +
    124
    │ │ │ │ +
    126 template<typename F>
    │ │ │ │ +
    │ │ │ │ +
    127 struct lazy_evaluate
    │ │ │ │ +
    128 {
    │ │ │ │ +
    129 typedef typename F::type type;
    │ │ │ │ +
    130 };
    │ │ │ │ +
    │ │ │ │ +
    131
    │ │ │ │ +
    133 template<typename F>
    │ │ │ │ +
    │ │ │ │ +
    134 struct lazy_identity
    │ │ │ │ +
    135 {
    │ │ │ │ +
    136 typedef F type;
    │ │ │ │ +
    137 };
    │ │ │ │ +
    │ │ │ │ +
    138
    │ │ │ │ +
    140 template<typename F>
    │ │ │ │ +
    │ │ │ │ +
    141 struct evaluate_if_meta_function
    │ │ │ │ +
    142 {
    │ │ │ │ +
    143 typedef typename std::conditional<
    │ │ │ │ +
    144 std::is_base_of<meta_function,F>::value,
    │ │ │ │ +
    145 lazy_evaluate<F>,
    │ │ │ │ +
    146 lazy_identity<F>
    │ │ │ │ +
    147 >::type::type type;
    │ │ │ │ +
    148 };
    │ │ │ │ +
    │ │ │ │ +
    149
    │ │ │ │ +
    │ │ │ │ +
    150 namespace impl {
    │ │ │ │ +
    151
    │ │ │ │ +
    152 // Check if type is a or is derived from one of the tree path types
    │ │ │ │ +
    153
    │ │ │ │ +
    154 // Default overload for types not representing a tree path
    │ │ │ │ +
    │ │ │ │ +
    155 constexpr auto isTreePath(void*)
    │ │ │ │ +
    156 -> std::false_type
    │ │ │ │ +
    157 {
    │ │ │ │ +
    158 return std::false_type();
    │ │ │ │ +
    159 }
    │ │ │ │ +
    │ │ │ │
    160
    │ │ │ │ -
    161 template<class T>
    │ │ │ │ -
    162 using TypeTreeConcept = decltype((
    │ │ │ │ -
    163 std::declval<T>().degree(),
    │ │ │ │ -
    164 T::isLeaf,
    │ │ │ │ -
    165 T::isPower,
    │ │ │ │ -
    166 T::isComposite,
    │ │ │ │ -
    167 true));
    │ │ │ │ +
    161 // Overload for instances of HybridTreePath<...>
    │ │ │ │ +
    162 template<class... I>
    │ │ │ │ +
    │ │ │ │ +
    163 constexpr auto isTreePath(const HybridTreePath<I...>*)
    │ │ │ │ +
    164 -> std::true_type
    │ │ │ │ +
    165 {
    │ │ │ │ +
    166 return std::true_type();
    │ │ │ │ +
    167 }
    │ │ │ │ +
    │ │ │ │
    168
    │ │ │ │ -
    169 public:
    │ │ │ │ -
    │ │ │ │ -
    171 TreeContainerVectorBackend(Container&& container) :
    │ │ │ │ -
    172 container_(std::move(container))
    │ │ │ │ -
    173 {}
    │ │ │ │ -
    │ │ │ │ -
    174
    │ │ │ │ -
    176 template <class Tree, TypeTreeConcept<Tree> = true>
    │ │ │ │ -
    │ │ │ │ -
    177 TreeContainerVectorBackend(const Tree& tree) :
    │ │ │ │ -
    178 TreeContainerVectorBackend()
    │ │ │ │ -
    179 {
    │ │ │ │ -
    180 this->resize(tree);
    │ │ │ │ -
    181 }
    │ │ │ │ -
    │ │ │ │ -
    182
    │ │ │ │ -
    184 template <class C = Container,
    │ │ │ │ -
    185 std::enable_if_t<std::is_default_constructible_v<C>, bool> = true>
    │ │ │ │ -
    │ │ │ │ -
    186 TreeContainerVectorBackend() :
    │ │ │ │ -
    187 container_()
    │ │ │ │ -
    188 {}
    │ │ │ │ -
    │ │ │ │ -
    189
    │ │ │ │ -
    190 template<class... T>
    │ │ │ │ -
    │ │ │ │ -
    191 decltype(auto) operator[](const HybridTreePath<T...>& path) const
    │ │ │ │ -
    192 {
    │ │ │ │ -
    193 return accessByTreePath(container_, path);
    │ │ │ │ -
    194 }
    │ │ │ │ -
    │ │ │ │ -
    195
    │ │ │ │ -
    196 template<class... T>
    │ │ │ │ -
    │ │ │ │ -
    197 decltype(auto) operator[](const HybridTreePath<T...>& path)
    │ │ │ │ -
    198 {
    │ │ │ │ -
    199 return accessByTreePath(container_, path);
    │ │ │ │ -
    200 }
    │ │ │ │ -
    │ │ │ │ -
    201
    │ │ │ │ -
    203 template<class Tree, TypeTreeConcept<Tree> = true>
    │ │ │ │ -
    │ │ │ │ -
    204 void resize(const Tree& tree)
    │ │ │ │ -
    205 {
    │ │ │ │ -
    206 resizeImpl(container_, tree, Dune::PriorityTag<5>{});
    │ │ │ │ -
    207 }
    │ │ │ │ -
    │ │ │ │ -
    208
    │ │ │ │ -
    │ │ │ │ -
    209 const Container& data() const
    │ │ │ │ -
    210 {
    │ │ │ │ -
    211 return container_;
    │ │ │ │ -
    212 }
    │ │ │ │ -
    │ │ │ │ -
    213
    │ │ │ │ -
    │ │ │ │ -
    214 Container& data()
    │ │ │ │ -
    215 {
    │ │ │ │ -
    216 return container_;
    │ │ │ │ -
    217 }
    │ │ │ │ -
    │ │ │ │ -
    218
    │ │ │ │ -
    219 private:
    │ │ │ │ -
    220 Container container_;
    │ │ │ │ -
    221 };
    │ │ │ │ -
    │ │ │ │ -
    222
    │ │ │ │ -
    223 template<class Container>
    │ │ │ │ -
    │ │ │ │ -
    224 auto makeTreeContainerVectorBackend(Container&& container)
    │ │ │ │ -
    225 {
    │ │ │ │ -
    226 return TreeContainerVectorBackend<std::decay_t<Container>>(std::forward<Container>(container));
    │ │ │ │ -
    227 }
    │ │ │ │ -
    │ │ │ │ -
    228
    │ │ │ │ -
    229 /*
    │ │ │ │ -
    230 * \brief A simple lambda for creating default constructible values from a node
    │ │ │ │ -
    231 *
    │ │ │ │ -
    232 * This simply returns LeafToValue<Node>{} for a given Node. It's needed
    │ │ │ │ -
    233 * because using a lambda expression in a using declaration is not allowed
    │ │ │ │ -
    234 * because it's an unevaluated context.
    │ │ │ │ -
    235 */
    │ │ │ │ -
    236 template<template<class Node> class LeafToValue>
    │ │ │ │ -
    │ │ │ │ -
    237 struct LeafToDefaultConstructibleValue
    │ │ │ │ -
    238 {
    │ │ │ │ -
    239 template<class Node>
    │ │ │ │ -
    │ │ │ │ -
    240 auto operator()(const Node& node) const
    │ │ │ │ -
    241 {
    │ │ │ │ -
    242 return LeafToValue<Node>{};
    │ │ │ │ -
    243 }
    │ │ │ │ -
    │ │ │ │ -
    244 };
    │ │ │ │ -
    │ │ │ │ -
    245
    │ │ │ │ -
    246 } // namespace Detail
    │ │ │ │ -
    247
    │ │ │ │ -
    267 template<class Tree, class LeafToValue>
    │ │ │ │ -
    │ │ │ │ -
    268 auto makeTreeContainer(const Tree& tree, LeafToValue&& leafToValue)
    │ │ │ │ -
    269 {
    │ │ │ │ -
    270 auto f = std::ref(leafToValue);
    │ │ │ │ -
    271 auto factory = Detail::ContainerFactory<decltype(f)>(f);
    │ │ │ │ -
    272 return Detail::makeTreeContainerVectorBackend(factory(tree));
    │ │ │ │ -
    273 }
    │ │ │ │ -
    │ │ │ │ -
    274
    │ │ │ │ -
    290 template<class Value, class Tree>
    │ │ │ │ -
    │ │ │ │ -
    291 auto makeTreeContainer(const Tree& tree)
    │ │ │ │ -
    292 {
    │ │ │ │ -
    293 return makeTreeContainer(tree, [](const auto&) {return Value{};});
    │ │ │ │ -
    294 }
    │ │ │ │ -
    │ │ │ │ -
    295
    │ │ │ │ -
    299 template<class Value, class Tree>
    │ │ │ │ -
    300 using UniformTreeContainer = std::decay_t<decltype(makeTreeContainer<Value>(std::declval<const Tree&>()))>;
    │ │ │ │ -
    301
    │ │ │ │ -
    305 template<template<class Node> class LeafToValue, class Tree>
    │ │ │ │ -
    306 using TreeContainer = std::decay_t<decltype(makeTreeContainer(std::declval<const Tree&>(), std::declval<Detail::LeafToDefaultConstructibleValue<LeafToValue>>()))>;
    │ │ │ │ -
    307
    │ │ │ │ -
    309
    │ │ │ │ -
    310 } // namespace TypeTree
    │ │ │ │ -
    311} //namespace Dune
    │ │ │ │ -
    312
    │ │ │ │ -
    313#endif // DUNE_TYPETREE_TREECONTAINER_HH
    │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::makeTreeContainer
    auto makeTreeContainer(const Tree &tree, LeafToValue &&leafToValue)
    Create container havin the same structure as the given tree.
    Definition treecontainer.hh:268
    │ │ │ │ -
    Dune::TypeTree::UniformTreeContainer
    std::decay_t< decltype(makeTreeContainer< Value >(std::declval< const Tree & >()))> UniformTreeContainer
    Alias to container type generated by makeTreeContainer for given tree type and uniform value type.
    Definition treecontainer.hh:300
    │ │ │ │ -
    Dune::TypeTree::TreeContainer
    std::decay_t< decltype(makeTreeContainer(std::declval< const Tree & >(), std::declval< Detail::LeafToDefaultConstructibleValue< LeafToValue > >()))> TreeContainer
    Alias to container type generated by makeTreeContainer for give tree type and when using LeafToValue ...
    Definition treecontainer.hh:306
    │ │ │ │ -
    Dune::TypeTree::degree
    std::size_t degree(const Node &node)
    Returns the degree of node as run time information.
    Definition nodeinterface.hh:79
    │ │ │ │ -
    Dune::TypeTree::treePath
    constexpr auto treePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:326
    │ │ │ │ +
    169 }
    │ │ │ │ +
    │ │ │ │ +
    170
    │ │ │ │ +
    181 template<class T>
    │ │ │ │ +
    │ │ │ │ +
    182 struct IsTreePath :
    │ │ │ │ +
    183 public decltype(impl::isTreePath((typename std::decay<T>::type*)(nullptr)))
    │ │ │ │ +
    184 {};
    │ │ │ │ +
    │ │ │ │ +
    185
    │ │ │ │ +
    192 template<class T>
    │ │ │ │ +
    │ │ │ │ +
    193 constexpr auto isTreePath(const T&)
    │ │ │ │ +
    194 -> IsTreePath<T>
    │ │ │ │ +
    195 {
    │ │ │ │ +
    196 return IsTreePath<T>();
    │ │ │ │ +
    197 }
    │ │ │ │ +
    │ │ │ │ +
    198
    │ │ │ │ +
    199
    │ │ │ │ +
    200 } // end namespace TypeTree
    │ │ │ │ +
    201} // end namespace Dune
    │ │ │ │ +
    202
    │ │ │ │ +
    203#endif // DUNE_TYPETREE_TYPETRAITS_HH
    │ │ │ │ + │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::NodeTag
    typename std::decay_t< Node >::NodeTag NodeTag
    Returns the node tag of the given Node.
    Definition nodeinterface.hh:70
    │ │ │ │ +
    Dune::TypeTree::ImplementationTag
    typename std::decay_t< T >::ImplementationTag ImplementationTag
    Returns the implementation tag of the given Node.
    Definition nodeinterface.hh:74
    │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::Detail::makeTreeContainerVectorBackend
    auto makeTreeContainerVectorBackend(Container &&container)
    Definition treecontainer.hh:224
    │ │ │ │ -
    Dune::TypeTree::Detail::ContainerFactory
    Definition treecontainer.hh:39
    │ │ │ │ -
    Dune::TypeTree::Detail::ContainerFactory::operator()
    auto operator()(const Node &node)
    Definition treecontainer.hh:63
    │ │ │ │ -
    Dune::TypeTree::Detail::ContainerFactory::ContainerFactory
    ContainerFactory(LeafToValue leafToValue)
    Create ContainerFactory.
    Definition treecontainer.hh:58
    │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::Detail::TreeContainerVectorBackend::resize
    void resize(const Tree &tree)
    Resize the (nested) container depending on the degree of the tree nodes.
    Definition treecontainer.hh:204
    │ │ │ │ -
    Dune::TypeTree::Detail::TreeContainerVectorBackend::data
    Container & data()
    Definition treecontainer.hh:214
    │ │ │ │ -
    Dune::TypeTree::Detail::TreeContainerVectorBackend::data
    const Container & data() const
    Definition treecontainer.hh:209
    │ │ │ │ -
    Dune::TypeTree::Detail::TreeContainerVectorBackend::TreeContainerVectorBackend
    TreeContainerVectorBackend(Container &&container)
    Move the passed container into the internal storage.
    Definition treecontainer.hh:171
    │ │ │ │ -
    Dune::TypeTree::Detail::TreeContainerVectorBackend::TreeContainerVectorBackend
    TreeContainerVectorBackend()
    Default constructor. The stored container might need to be resized before usage.
    Definition treecontainer.hh:186
    │ │ │ │ -
    Dune::TypeTree::Detail::TreeContainerVectorBackend::TreeContainerVectorBackend
    TreeContainerVectorBackend(const Tree &tree)
    Default construct the container and perform a resize depending on the tree-node degrees.
    Definition treecontainer.hh:177
    │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::Detail::LeafToDefaultConstructibleValue::operator()
    auto operator()(const Node &node) const
    Definition treecontainer.hh:240
    │ │ │ │ +
    Dune::TypeTree::isTreePath
    constexpr auto isTreePath(const T &) -> IsTreePath< T >
    Check if given object represents a tree path.
    Definition typetraits.hh:193
    │ │ │ │ +
    Dune::TypeTree::declptr
    T * declptr()
    Helper function for generating a pointer to a value of type T in an unevaluated operand setting.
    │ │ │ │ +
    Dune::TypeTree::impl::isTreePath
    constexpr auto isTreePath(void *) -> std::false_type
    Definition typetraits.hh:155
    │ │ │ │
    Dune::TypeTree::HybridTreePath
    A hybrid version of TreePath that supports both compile time and run time indices.
    Definition treepath.hh:158
    │ │ │ │ +
    Dune::first_type
    Definition typetraits.hh:21
    │ │ │ │ +
    Dune::first_type< T0, T... >::type
    T0 type
    Definition typetraits.hh:26
    │ │ │ │ +
    Dune::TypeTree::has_node_tag
    Definition typetraits.hh:33
    │ │ │ │ +
    Dune::TypeTree::has_node_tag::value
    static constexpr bool value
    True if class T defines a NodeTag.
    Definition typetraits.hh:43
    │ │ │ │ +
    Dune::TypeTree::has_node_tag::test
    static yes test(NodeTag< X > *)
    │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::has_node_tag::yes
    Definition typetraits.hh:34
    │ │ │ │ +
    Dune::TypeTree::has_node_tag::yes::dummy
    char dummy[1]
    Definition typetraits.hh:34
    │ │ │ │ +
    Dune::TypeTree::has_node_tag::no
    Definition typetraits.hh:35
    │ │ │ │ +
    Dune::TypeTree::has_node_tag::no::dummy
    char dummy[2]
    Definition typetraits.hh:35
    │ │ │ │ +
    Dune::TypeTree::has_node_tag_value
    Definition typetraits.hh:48
    │ │ │ │ +
    Dune::TypeTree::has_node_tag_value::test
    static maybe< std::is_base_of< V, NodeTag< X > >::value > test(NodeTag< X > *a)
    │ │ │ │ +
    Dune::TypeTree::has_node_tag_value::value
    static constexpr bool value
    True if class T defines a NodeTag of type V.
    Definition typetraits.hh:61
    │ │ │ │ + │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::has_node_tag_value::maybe::dummy
    char dummy[N+1]
    Definition typetraits.hh:50
    │ │ │ │ +
    Dune::TypeTree::has_node_tag_value::yes
    Definition typetraits.hh:51
    │ │ │ │ +
    Dune::TypeTree::has_node_tag_value::yes::dummy
    char dummy[2]
    Definition typetraits.hh:51
    │ │ │ │ +
    Dune::TypeTree::has_node_tag_value::no
    Definition typetraits.hh:52
    │ │ │ │ +
    Dune::TypeTree::has_node_tag_value::no::dummy
    char dummy[1]
    Definition typetraits.hh:52
    │ │ │ │ +
    Dune::TypeTree::has_implementation_tag
    Definition typetraits.hh:66
    │ │ │ │ +
    Dune::TypeTree::has_implementation_tag::test
    static yes test(ImplementationTag< X > *)
    │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::has_implementation_tag::value
    static constexpr bool value
    True if class T defines an ImplementationTag.
    Definition typetraits.hh:76
    │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::has_implementation_tag::yes::dummy
    char dummy[1]
    Definition typetraits.hh:67
    │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::has_implementation_tag::no::dummy
    char dummy[2]
    Definition typetraits.hh:68
    │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::has_implementation_tag_value::test
    static maybe< std::is_base_of< V, ImplementationTag< X > >::value > test(ImplementationTag< X > *a)
    │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::has_implementation_tag_value::value
    static constexpr bool value
    True if class T defines an ImplementationTag of type V.
    Definition typetraits.hh:94
    │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::has_implementation_tag_value::maybe::dummy
    char dummy[N+1]
    Definition typetraits.hh:83
    │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::has_implementation_tag_value::yes::dummy
    char dummy[2]
    Definition typetraits.hh:84
    │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::has_implementation_tag_value::no::dummy
    char dummy[1]
    Definition typetraits.hh:85
    │ │ │ │ +
    Dune::TypeTree::AlwaysVoid
    Definition typetraits.hh:99
    │ │ │ │ +
    Dune::TypeTree::AlwaysVoid::type
    void type
    Definition typetraits.hh:100
    │ │ │ │ +
    Dune::TypeTree::meta_function
    Marker tag declaring a meta function.
    Definition typetraits.hh:123
    │ │ │ │ +
    Dune::TypeTree::lazy_evaluate
    Helper meta function to delay evaluation of F.
    Definition typetraits.hh:128
    │ │ │ │ +
    Dune::TypeTree::lazy_evaluate::type
    F::type type
    Definition typetraits.hh:129
    │ │ │ │ +
    Dune::TypeTree::lazy_identity
    Identity function.
    Definition typetraits.hh:135
    │ │ │ │ +
    Dune::TypeTree::lazy_identity::type
    F type
    Definition typetraits.hh:136
    │ │ │ │ +
    Dune::TypeTree::evaluate_if_meta_function
    Meta function that evaluates its argument iff it inherits from meta_function.
    Definition typetraits.hh:142
    │ │ │ │ +
    Dune::TypeTree::evaluate_if_meta_function::type
    std::conditional< std::is_base_of< meta_function, F >::value, lazy_evaluate< F >, lazy_identity< F > >::type::type type
    Definition typetraits.hh:147
    │ │ │ │ +
    Dune::TypeTree::IsTreePath
    Check if type represents a tree path.
    Definition typetraits.hh:184
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,367 +1,346 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -treecontainer.hh │ │ │ │ │ +typetraits.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_TREECONTAINER_HH │ │ │ │ │ -7#define DUNE_TYPETREE_TREECONTAINER_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_TYPETRAITS_HH │ │ │ │ │ +7#define DUNE_TYPETREE_TYPETRAITS_HH │ │ │ │ │ 8 │ │ │ │ │ 9#include │ │ │ │ │ -10#include │ │ │ │ │ -11#include │ │ │ │ │ -12#include │ │ │ │ │ -13 │ │ │ │ │ -14#include │ │ │ │ │ -15#include │ │ │ │ │ -16#include │ │ │ │ │ -17#include │ │ │ │ │ -18 │ │ │ │ │ -19#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_e_e_p_a_t_h_._h_h> │ │ │ │ │ -20 │ │ │ │ │ -21namespace _D_u_n_e { │ │ │ │ │ -22 namespace TypeTree { │ │ │ │ │ -23 │ │ │ │ │ -24 namespace Detail { │ │ │ │ │ -25 │ │ │ │ │ -26 /* │ │ │ │ │ -27 * \brief A factory class creating a hybrid container compatible with a type │ │ │ │ │ -tree │ │ │ │ │ -28 * │ │ │ │ │ -29 * This class allows to create a nested hybrid container having the same │ │ │ │ │ -structure │ │ │ │ │ -30 * as a given type tree. Power nodes are represented as std::array's while │ │ │ │ │ -composite │ │ │ │ │ -31 * nodes are represented as Dune::TupleVector's. The stored values for the │ │ │ │ │ -leaf nodes │ │ │ │ │ -32 * are creating using a given predicate. Once created, the factory provides │ │ │ │ │ -an │ │ │ │ │ -33 * operator() creating the container for the tree given as argument. │ │ │ │ │ -34 * │ │ │ │ │ -35 * \tparam LeafToValue Type of a predicate that determines the stored values │ │ │ │ │ -at the leafs │ │ │ │ │ -36 */ │ │ │ │ │ -37 template │ │ │ │ │ -_3_8 class _C_o_n_t_a_i_n_e_r_F_a_c_t_o_r_y │ │ │ │ │ -39 { │ │ │ │ │ -40 template │ │ │ │ │ -41 using DynamicDegreeConcept = decltype((std::size_t(std::declval()._d_e_g_r_e_e │ │ │ │ │ -()), true)); │ │ │ │ │ -42 │ │ │ │ │ -43 template │ │ │ │ │ -44 using StaticDegreeConcept = decltype((std::integral_constant{}, true)); │ │ │ │ │ +10#include │ │ │ │ │ +11 │ │ │ │ │ +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_/_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h> │ │ │ │ │ +14 │ │ │ │ │ +15namespace _D_u_n_e { │ │ │ │ │ +16 │ │ │ │ │ +17 // Provide some more C++11 TMP helpers. │ │ │ │ │ +18 // These should be upstreamed to dune-common ASAP. │ │ │ │ │ +19 │ │ │ │ │ +20 template │ │ │ │ │ +_2_1 struct _f_i_r_s_t___t_y_p_e; │ │ │ │ │ +22 │ │ │ │ │ +23 template │ │ │ │ │ +_2_4 struct _f_i_r_s_t___t_y_p_e │ │ │ │ │ +25 { │ │ │ │ │ +_2_6 typedef T0 _t_y_p_e; │ │ │ │ │ +27 }; │ │ │ │ │ +28 │ │ │ │ │ +29 namespace TypeTree { │ │ │ │ │ +30 │ │ │ │ │ +31 template │ │ │ │ │ +_3_2 struct _h_a_s___n_o_d_e___t_a_g │ │ │ │ │ +33 { │ │ │ │ │ +_3_4 struct _y_e_s { char _d_u_m_m_y[1]; }; │ │ │ │ │ +_3_5 struct _n_o { char _d_u_m_m_y[2]; }; │ │ │ │ │ +36 │ │ │ │ │ +37 template │ │ │ │ │ +_3_8 static _y_e_s _t_e_s_t(_N_o_d_e_T_a_g_<_X_> *); │ │ │ │ │ +39 template │ │ │ │ │ +_4_0 static _n_o _t_e_s_t(...); │ │ │ │ │ +41 │ │ │ │ │ +_4_3 constexpr static bool _v_a_l_u_e = sizeof(test(0)) == sizeof(_y_e_s); │ │ │ │ │ +44 }; │ │ │ │ │ 45 │ │ │ │ │ -46 template │ │ │ │ │ -47 using DynamicChildAccessConcept = decltype((std::declval().child(0u), │ │ │ │ │ -true)); │ │ │ │ │ -48 │ │ │ │ │ -49 public: │ │ │ │ │ -50 │ │ │ │ │ -_5_8 _C_o_n_t_a_i_n_e_r_F_a_c_t_o_r_y(LeafToValue leafToValue) : │ │ │ │ │ -59 leafToValue_(leafToValue) │ │ │ │ │ -60 {} │ │ │ │ │ -61 │ │ │ │ │ -62 template │ │ │ │ │ -_6_3 auto _o_p_e_r_a_t_o_r_(_)(const Node& node) │ │ │ │ │ -64 { │ │ │ │ │ -65 return (*this)(node, Dune::PriorityTag<5>{}); │ │ │ │ │ -66 } │ │ │ │ │ -67 │ │ │ │ │ -68 private: │ │ │ │ │ +46 template │ │ │ │ │ +_4_7 struct _h_a_s___n_o_d_e___t_a_g___v_a_l_u_e │ │ │ │ │ +48 { │ │ │ │ │ +49 template │ │ │ │ │ +_5_0 struct _m_a_y_b_e { char _d_u_m_m_y[N+1]; }; │ │ │ │ │ +_5_1 struct _y_e_s { char _d_u_m_m_y[2]; }; │ │ │ │ │ +_5_2 struct _n_o { char _d_u_m_m_y[1]; }; │ │ │ │ │ +53 │ │ │ │ │ +54 template │ │ │ │ │ +55 static _m_a_y_b_e_<_s_t_d_:_:_i_s___b_a_s_e___o_f_<_V_,_ _N_o_d_e_T_a_g_<_X_>>_:_:_v_a_l_u_e> │ │ │ │ │ +_5_6 _t_e_s_t(_N_o_d_e_T_a_g_<_X_> * a); │ │ │ │ │ +57 template │ │ │ │ │ +_5_8 static _n_o _t_e_s_t(...); │ │ │ │ │ +59 │ │ │ │ │ +_6_1 constexpr static bool _v_a_l_u_e = sizeof(test(0)) == sizeof(_y_e_s); │ │ │ │ │ +62 }; │ │ │ │ │ +63 │ │ │ │ │ +64 template │ │ │ │ │ +_6_5 struct _h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g │ │ │ │ │ +66 { │ │ │ │ │ +_6_7 struct _y_e_s { char _d_u_m_m_y[1]; }; │ │ │ │ │ +_6_8 struct _n_o { char _d_u_m_m_y[2]; }; │ │ │ │ │ 69 │ │ │ │ │ -70 template = true> │ │ │ │ │ -72 auto _o_p_e_r_a_t_o_r_(_)(const Node& node, Dune::PriorityTag<4>) │ │ │ │ │ -73 { │ │ │ │ │ -74 return leafToValue_(node); │ │ │ │ │ -75 } │ │ │ │ │ -76 │ │ │ │ │ -77 template = true, │ │ │ │ │ -79 DynamicChildAccessConcept = true> │ │ │ │ │ -80 auto _o_p_e_r_a_t_o_r_(_)(const Node& node, Dune::PriorityTag<3>) │ │ │ │ │ +70 template │ │ │ │ │ +_7_1 static _y_e_s _t_e_s_t(_I_m_p_l_e_m_e_n_t_a_t_i_o_n_T_a_g_<_X_> *); │ │ │ │ │ +72 template │ │ │ │ │ +_7_3 static _n_o _t_e_s_t(...); │ │ │ │ │ +74 │ │ │ │ │ +_7_6 constexpr static bool _v_a_l_u_e = sizeof(test(0)) == sizeof(_y_e_s); │ │ │ │ │ +77 }; │ │ │ │ │ +78 │ │ │ │ │ +79 template │ │ │ │ │ +_8_0 struct _h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e │ │ │ │ │ 81 { │ │ │ │ │ -82 return Dune::unpackIntegerSequence([&](auto... indices) { │ │ │ │ │ -83 return std::array{(*this)(node.child(indices))...}; │ │ │ │ │ -84 }, std::make_index_sequence()); │ │ │ │ │ -85 } │ │ │ │ │ +82 template │ │ │ │ │ +_8_3 struct _m_a_y_b_e { char _d_u_m_m_y[N+1]; }; │ │ │ │ │ +_8_4 struct _y_e_s { char _d_u_m_m_y[2]; }; │ │ │ │ │ +_8_5 struct _n_o { char _d_u_m_m_y[1]; }; │ │ │ │ │ 86 │ │ │ │ │ -87 template = true, │ │ │ │ │ -89 DynamicChildAccessConcept = true> │ │ │ │ │ -90 auto _o_p_e_r_a_t_o_r_(_)(const Node& node, Dune::PriorityTag<2>) │ │ │ │ │ -91 { │ │ │ │ │ -92 using TransformedChild = decltype((*this)(node.child(0))); │ │ │ │ │ -93 std::vector container; │ │ │ │ │ -94 container.reserve(node.degree()); │ │ │ │ │ -95 for (std::size_t i = 0; i < node.degree(); ++i) │ │ │ │ │ -96 container.emplace_back((*this)(node.child(i))); │ │ │ │ │ -97 return container; │ │ │ │ │ -98 } │ │ │ │ │ -99 │ │ │ │ │ -100 template = true> │ │ │ │ │ -102 auto _o_p_e_r_a_t_o_r_(_)(const Node& node, Dune::PriorityTag<1>) │ │ │ │ │ -103 { │ │ │ │ │ -104 return Dune::unpackIntegerSequence([&](auto... indices) { │ │ │ │ │ -105 return Dune::makeTupleVector((*this)(node.child(indices))...); │ │ │ │ │ -106 }, std::make_index_sequence()); │ │ │ │ │ -107 } │ │ │ │ │ +87 template │ │ │ │ │ +88 static _m_a_y_b_e_<_s_t_d_:_:_i_s___b_a_s_e___o_f_<_V_,_ _I_m_p_l_e_m_e_n_t_a_t_i_o_n_T_a_g_<_X_>>_:_:_v_a_l_u_e> │ │ │ │ │ +_8_9 _t_e_s_t(_I_m_p_l_e_m_e_n_t_a_t_i_o_n_T_a_g_<_X_> * a); │ │ │ │ │ +90 template │ │ │ │ │ +_9_1 static _n_o _t_e_s_t(...); │ │ │ │ │ +92 │ │ │ │ │ +_9_4 constexpr static bool _v_a_l_u_e = sizeof(test(0)) == sizeof(_y_e_s); │ │ │ │ │ +95 }; │ │ │ │ │ +96 │ │ │ │ │ +97 template │ │ │ │ │ +_9_8 struct _A_l_w_a_y_s_V_o_i_d │ │ │ │ │ +99 { │ │ │ │ │ +_1_0_0 typedef void _t_y_p_e; │ │ │ │ │ +101 }; │ │ │ │ │ +102 │ │ │ │ │ +103 │ │ │ │ │ +105 template │ │ │ │ │ +_1_0_6 T* _d_e_c_l_p_t_r(); │ │ │ │ │ +107 │ │ │ │ │ 108 │ │ │ │ │ -109 private: │ │ │ │ │ -110 LeafToValue leafToValue_; │ │ │ │ │ -111 }; │ │ │ │ │ -112 │ │ │ │ │ -113 │ │ │ │ │ -114 /* │ │ │ │ │ -115 * \brief Wrap nested container to provide a VectorBackend │ │ │ │ │ -116 */ │ │ │ │ │ -117 template │ │ │ │ │ -_1_1_8 class _T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d │ │ │ │ │ -119 { │ │ │ │ │ -120 template │ │ │ │ │ -121 static constexpr decltype(auto) accessByTreePath(C&& container, const │ │ │ │ │ -_H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_>& path) │ │ │ │ │ -122 { │ │ │ │ │ -123 return container; │ │ │ │ │ -124 } │ │ │ │ │ -125 │ │ │ │ │ -126 template │ │ │ │ │ -127 static constexpr decltype(auto) accessByTreePath(C&& container, const │ │ │ │ │ -_H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& path) │ │ │ │ │ +109 // Support for lazy evaluation of meta functions. This is required when │ │ │ │ │ +doing │ │ │ │ │ +110 // nested tag dispatch without C++11-style typedefs (based on using │ │ │ │ │ +syntax). │ │ │ │ │ +111 // The standard struct-based meta functions cause premature evaluation in a │ │ │ │ │ +112 // context that is not SFINAE-compatible. We thus have to return the meta │ │ │ │ │ +function │ │ │ │ │ +113 // without evaluating it, placing that burden on the caller. On the other │ │ │ │ │ +hand, │ │ │ │ │ +114 // the lookup will often directly be the target type, so here is some │ │ │ │ │ +helper code │ │ │ │ │ +115 // to automatically do the additional evaluation if necessary. │ │ │ │ │ +116 // Too bad that the new syntax is GCC 4.6+... │ │ │ │ │ +117 │ │ │ │ │ +118 │ │ │ │ │ +120 │ │ │ │ │ +_1_2_3 struct _m_e_t_a___f_u_n_c_t_i_o_n {}; │ │ │ │ │ +124 │ │ │ │ │ +126 template │ │ │ │ │ +_1_2_7 struct _l_a_z_y___e_v_a_l_u_a_t_e │ │ │ │ │ 128 { │ │ │ │ │ -129 auto head = path[Dune::Indices::_0]; │ │ │ │ │ -130 auto tailPath = Dune::unpackIntegerSequence([&](auto... i){ │ │ │ │ │ -131 return _t_r_e_e_P_a_t_h(path[Dune::index_constant{}]...); │ │ │ │ │ -132 }, std::make_index_sequence()); │ │ │ │ │ -133 return accessByTreePath(container[head], tailPath); │ │ │ │ │ -134 } │ │ │ │ │ -135 │ │ │ │ │ -136 template = true> │ │ │ │ │ -138 static void resizeImpl(C& /*container*/, const Tree& /*tree*/, Dune:: │ │ │ │ │ -PriorityTag<2>) │ │ │ │ │ -139 { │ │ │ │ │ -140 /* do nothing */ │ │ │ │ │ -141 } │ │ │ │ │ -142 │ │ │ │ │ -143 template().resize(0u))> │ │ │ │ │ -145 static void resizeImpl(C& container, const Tree& tree, Dune:: │ │ │ │ │ -PriorityTag<1>) │ │ │ │ │ -146 { │ │ │ │ │ -147 container.resize(tree.degree()); │ │ │ │ │ -148 Dune::Hybrid::forEach(Dune::range(tree.degree()), [&](auto i) { │ │ │ │ │ -149 resizeImpl(container[i], tree.child(i), Dune::PriorityTag<5>{}); │ │ │ │ │ -150 }); │ │ │ │ │ -151 } │ │ │ │ │ -152 │ │ │ │ │ -153 template │ │ │ │ │ -154 static void resizeImpl(C& container, const Tree& tree, Dune:: │ │ │ │ │ -PriorityTag<0>) │ │ │ │ │ -155 { │ │ │ │ │ -156 Dune::Hybrid::forEach(Dune::range(tree.degree()), [&](auto i) { │ │ │ │ │ -157 resizeImpl(container[i], tree.child(i), Dune::PriorityTag<5>{}); │ │ │ │ │ -158 }); │ │ │ │ │ +_1_2_9 typedef typename F::type _t_y_p_e; │ │ │ │ │ +130 }; │ │ │ │ │ +131 │ │ │ │ │ +133 template │ │ │ │ │ +_1_3_4 struct _l_a_z_y___i_d_e_n_t_i_t_y │ │ │ │ │ +135 { │ │ │ │ │ +_1_3_6 typedef F _t_y_p_e; │ │ │ │ │ +137 }; │ │ │ │ │ +138 │ │ │ │ │ +140 template │ │ │ │ │ +_1_4_1 struct _e_v_a_l_u_a_t_e___i_f___m_e_t_a___f_u_n_c_t_i_o_n │ │ │ │ │ +142 { │ │ │ │ │ +143 typedef typename std::conditional< │ │ │ │ │ +144 std::is_base_of::value, │ │ │ │ │ +145 _l_a_z_y___e_v_a_l_u_a_t_e_<_F_>, │ │ │ │ │ +146 _l_a_z_y___i_d_e_n_t_i_t_y_<_F_> │ │ │ │ │ +_1_4_7 >::type::type _t_y_p_e; │ │ │ │ │ +148 }; │ │ │ │ │ +149 │ │ │ │ │ +_1_5_0 namespace impl { │ │ │ │ │ +151 │ │ │ │ │ +152 // Check if type is a or is derived from one of the tree path types │ │ │ │ │ +153 │ │ │ │ │ +154 // Default overload for types not representing a tree path │ │ │ │ │ +_1_5_5 constexpr auto _i_s_T_r_e_e_P_a_t_h(void*) │ │ │ │ │ +156 -> std::false_type │ │ │ │ │ +157 { │ │ │ │ │ +158 return std::false_type(); │ │ │ │ │ 159 } │ │ │ │ │ 160 │ │ │ │ │ -161 template │ │ │ │ │ -162 using TypeTreeConcept = decltype(( │ │ │ │ │ -163 std::declval().degree(), │ │ │ │ │ -164 T::isLeaf, │ │ │ │ │ -165 T::isPower, │ │ │ │ │ -166 T::isComposite, │ │ │ │ │ -167 true)); │ │ │ │ │ +161 // Overload for instances of HybridTreePath<...> │ │ │ │ │ +162 template │ │ │ │ │ +_1_6_3 constexpr auto _i_s_T_r_e_e_P_a_t_h(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_I_._._._>*) │ │ │ │ │ +164 -> std::true_type │ │ │ │ │ +165 { │ │ │ │ │ +166 return std::true_type(); │ │ │ │ │ +167 } │ │ │ │ │ 168 │ │ │ │ │ -169 public: │ │ │ │ │ -_1_7_1 _T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d(Container&& container) : │ │ │ │ │ -172 container_(std::move(container)) │ │ │ │ │ -173 {} │ │ │ │ │ -174 │ │ │ │ │ -176 template = true> │ │ │ │ │ -_1_7_7 _T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d(const Tree& tree) : │ │ │ │ │ -178 _T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d() │ │ │ │ │ -179 { │ │ │ │ │ -180 this->resize(tree); │ │ │ │ │ -181 } │ │ │ │ │ -182 │ │ │ │ │ -184 template , bool> = true> │ │ │ │ │ -_1_8_6 _T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d() : │ │ │ │ │ -187 container_() │ │ │ │ │ -188 {} │ │ │ │ │ -189 │ │ │ │ │ -190 template │ │ │ │ │ -_1_9_1 decltype(auto) operator[](const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& path) const │ │ │ │ │ -192 { │ │ │ │ │ -193 return accessByTreePath(container_, path); │ │ │ │ │ -194 } │ │ │ │ │ -195 │ │ │ │ │ -196 template │ │ │ │ │ -_1_9_7 decltype(auto) operator[](const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& path) │ │ │ │ │ -198 { │ │ │ │ │ -199 return accessByTreePath(container_, path); │ │ │ │ │ -200 } │ │ │ │ │ -201 │ │ │ │ │ -203 template = true> │ │ │ │ │ -_2_0_4 void _r_e_s_i_z_e(const Tree& tree) │ │ │ │ │ -205 { │ │ │ │ │ -206 resizeImpl(container_, tree, Dune::PriorityTag<5>{}); │ │ │ │ │ -207 } │ │ │ │ │ -208 │ │ │ │ │ -_2_0_9 const Container& _d_a_t_a() const │ │ │ │ │ -210 { │ │ │ │ │ -211 return container_; │ │ │ │ │ -212 } │ │ │ │ │ -213 │ │ │ │ │ -_2_1_4 Container& _d_a_t_a() │ │ │ │ │ -215 { │ │ │ │ │ -216 return container_; │ │ │ │ │ -217 } │ │ │ │ │ -218 │ │ │ │ │ -219 private: │ │ │ │ │ -220 Container container_; │ │ │ │ │ -221 }; │ │ │ │ │ -222 │ │ │ │ │ -223 template │ │ │ │ │ -_2_2_4 auto _m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d(Container&& container) │ │ │ │ │ -225 { │ │ │ │ │ -226 return _T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d_<_s_t_d_:_:_d_e_c_a_y___t_<_C_o_n_t_a_i_n_e_r_>>(std:: │ │ │ │ │ -forward(container)); │ │ │ │ │ -227 } │ │ │ │ │ -228 │ │ │ │ │ -229 /* │ │ │ │ │ -230 * \brief A simple lambda for creating default constructible values from a │ │ │ │ │ -node │ │ │ │ │ -231 * │ │ │ │ │ -232 * This simply returns LeafToValue{} for a given Node. It's needed │ │ │ │ │ -233 * because using a lambda expression in a using declaration is not allowed │ │ │ │ │ -234 * because it's an unevaluated context. │ │ │ │ │ -235 */ │ │ │ │ │ -236 template class LeafToValue> │ │ │ │ │ -_2_3_7 struct _L_e_a_f_T_o_D_e_f_a_u_l_t_C_o_n_s_t_r_u_c_t_i_b_l_e_V_a_l_u_e │ │ │ │ │ -238 { │ │ │ │ │ -239 template │ │ │ │ │ -_2_4_0 auto _o_p_e_r_a_t_o_r_(_)(const Node& node) const │ │ │ │ │ -241 { │ │ │ │ │ -242 return LeafToValue{}; │ │ │ │ │ -243 } │ │ │ │ │ -244 }; │ │ │ │ │ -245 │ │ │ │ │ -246 } // namespace Detail │ │ │ │ │ -247 │ │ │ │ │ -267 template │ │ │ │ │ -_2_6_8 auto _m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r(const Tree& tree, LeafToValue&& leafToValue) │ │ │ │ │ -269 { │ │ │ │ │ -270 auto f = std::ref(leafToValue); │ │ │ │ │ -271 auto factory = _D_e_t_a_i_l_:_:_C_o_n_t_a_i_n_e_r_F_a_c_t_o_r_y_<_d_e_c_l_t_y_p_e_(_f_)_>(f); │ │ │ │ │ -272 return Detail::makeTreeContainerVectorBackend(factory(tree)); │ │ │ │ │ -273 } │ │ │ │ │ -274 │ │ │ │ │ -290 template │ │ │ │ │ -_2_9_1 auto _m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r(const Tree& tree) │ │ │ │ │ -292 { │ │ │ │ │ -293 return _m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r(tree, [](const auto&) {return Value{};}); │ │ │ │ │ -294 } │ │ │ │ │ -295 │ │ │ │ │ -299 template │ │ │ │ │ -_3_0_0 using _U_n_i_f_o_r_m_T_r_e_e_C_o_n_t_a_i_n_e_r = std::decay_t │ │ │ │ │ -(std::declval()))>; │ │ │ │ │ -301 │ │ │ │ │ -305 template class LeafToValue, class Tree> │ │ │ │ │ -_3_0_6 using _T_r_e_e_C_o_n_t_a_i_n_e_r = std::decay_t(), std::declval>()))>; │ │ │ │ │ -307 │ │ │ │ │ -309 │ │ │ │ │ -310 } // namespace TypeTree │ │ │ │ │ -311} //namespace Dune │ │ │ │ │ -312 │ │ │ │ │ -313#endif // DUNE_TYPETREE_TREECONTAINER_HH │ │ │ │ │ +169 } │ │ │ │ │ +170 │ │ │ │ │ +181 template │ │ │ │ │ +_1_8_2 struct _I_s_T_r_e_e_P_a_t_h : │ │ │ │ │ +183 public decltype(impl::isTreePath((typename std::decay::type*)(nullptr))) │ │ │ │ │ +184 {}; │ │ │ │ │ +185 │ │ │ │ │ +192 template │ │ │ │ │ +_1_9_3 constexpr auto _i_s_T_r_e_e_P_a_t_h(const T&) │ │ │ │ │ +194 -> _I_s_T_r_e_e_P_a_t_h_<_T_> │ │ │ │ │ +195 { │ │ │ │ │ +196 return _I_s_T_r_e_e_P_a_t_h_<_T_>(); │ │ │ │ │ +197 } │ │ │ │ │ +198 │ │ │ │ │ +199 │ │ │ │ │ +200 } // end namespace TypeTree │ │ │ │ │ +201} // end namespace Dune │ │ │ │ │ +202 │ │ │ │ │ +203#endif // DUNE_TYPETREE_TYPETRAITS_HH │ │ │ │ │ +_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h │ │ │ │ │ _t_r_e_e_p_a_t_h_._h_h │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r │ │ │ │ │ -auto makeTreeContainer(const Tree &tree, LeafToValue &&leafToValue) │ │ │ │ │ -Create container havin the same structure as the given tree. │ │ │ │ │ -DDeeffiinniittiioonn treecontainer.hh:268 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_U_n_i_f_o_r_m_T_r_e_e_C_o_n_t_a_i_n_e_r │ │ │ │ │ -std::decay_t< decltype(makeTreeContainer< Value >(std::declval< const Tree & > │ │ │ │ │ -()))> UniformTreeContainer │ │ │ │ │ -Alias to container type generated by makeTreeContainer for given tree type and │ │ │ │ │ -uniform value type. │ │ │ │ │ -DDeeffiinniittiioonn treecontainer.hh:300 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r │ │ │ │ │ -std::decay_t< decltype(makeTreeContainer(std::declval< const Tree & >(), std:: │ │ │ │ │ -declval< Detail::LeafToDefaultConstructibleValue< LeafToValue > >()))> │ │ │ │ │ -TreeContainer │ │ │ │ │ -Alias to container type generated by makeTreeContainer for give tree type and │ │ │ │ │ -when using LeafToValue ... │ │ │ │ │ -DDeeffiinniittiioonn treecontainer.hh:306 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_d_e_g_r_e_e │ │ │ │ │ -std::size_t degree(const Node &node) │ │ │ │ │ -Returns the degree of node as run time information. │ │ │ │ │ -DDeeffiinniittiioonn nodeinterface.hh:79 │ │ │ │ │ -_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_:_:_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_:_:_I_m_p_l_e_m_e_n_t_a_t_i_o_n_T_a_g │ │ │ │ │ +typename std::decay_t< T >::ImplementationTag ImplementationTag │ │ │ │ │ +Returns the implementation tag of the given Node. │ │ │ │ │ +DDeeffiinniittiioonn nodeinterface.hh:74 │ │ │ │ │ _D_u_n_e │ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d │ │ │ │ │ -auto makeTreeContainerVectorBackend(Container &&container) │ │ │ │ │ -DDeeffiinniittiioonn treecontainer.hh:224 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_C_o_n_t_a_i_n_e_r_F_a_c_t_o_r_y │ │ │ │ │ -DDeeffiinniittiioonn treecontainer.hh:39 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_C_o_n_t_a_i_n_e_r_F_a_c_t_o_r_y_:_:_o_p_e_r_a_t_o_r_(_) │ │ │ │ │ -auto operator()(const Node &node) │ │ │ │ │ -DDeeffiinniittiioonn treecontainer.hh:63 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_C_o_n_t_a_i_n_e_r_F_a_c_t_o_r_y_:_:_C_o_n_t_a_i_n_e_r_F_a_c_t_o_r_y │ │ │ │ │ -ContainerFactory(LeafToValue leafToValue) │ │ │ │ │ -Create ContainerFactory. │ │ │ │ │ -DDeeffiinniittiioonn treecontainer.hh:58 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d │ │ │ │ │ -DDeeffiinniittiioonn treecontainer.hh:119 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d_:_:_r_e_s_i_z_e │ │ │ │ │ -void resize(const Tree &tree) │ │ │ │ │ -Resize the (nested) container depending on the degree of the tree nodes. │ │ │ │ │ -DDeeffiinniittiioonn treecontainer.hh:204 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d_:_:_d_a_t_a │ │ │ │ │ -Container & data() │ │ │ │ │ -DDeeffiinniittiioonn treecontainer.hh:214 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d_:_:_d_a_t_a │ │ │ │ │ -const Container & data() const │ │ │ │ │ -DDeeffiinniittiioonn treecontainer.hh:209 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d │ │ │ │ │ -TreeContainerVectorBackend(Container &&container) │ │ │ │ │ -Move the passed container into the internal storage. │ │ │ │ │ -DDeeffiinniittiioonn treecontainer.hh:171 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d │ │ │ │ │ -TreeContainerVectorBackend() │ │ │ │ │ -Default constructor. The stored container might need to be resized before │ │ │ │ │ -usage. │ │ │ │ │ -DDeeffiinniittiioonn treecontainer.hh:186 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d │ │ │ │ │ -TreeContainerVectorBackend(const Tree &tree) │ │ │ │ │ -Default construct the container and perform a resize depending on the tree-node │ │ │ │ │ -degrees. │ │ │ │ │ -DDeeffiinniittiioonn treecontainer.hh:177 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_L_e_a_f_T_o_D_e_f_a_u_l_t_C_o_n_s_t_r_u_c_t_i_b_l_e_V_a_l_u_e │ │ │ │ │ -DDeeffiinniittiioonn treecontainer.hh:238 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_L_e_a_f_T_o_D_e_f_a_u_l_t_C_o_n_s_t_r_u_c_t_i_b_l_e_V_a_l_u_e_:_:_o_p_e_r_a_t_o_r_(_) │ │ │ │ │ -auto operator()(const Node &node) const │ │ │ │ │ -DDeeffiinniittiioonn treecontainer.hh:240 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_s_T_r_e_e_P_a_t_h │ │ │ │ │ +constexpr auto isTreePath(const T &) -> IsTreePath< T > │ │ │ │ │ +Check if given object represents a tree path. │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:193 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_d_e_c_l_p_t_r │ │ │ │ │ +T * declptr() │ │ │ │ │ +Helper function for generating a pointer to a value of type T in an unevaluated │ │ │ │ │ +operand setting. │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_m_p_l_:_:_i_s_T_r_e_e_P_a_t_h │ │ │ │ │ +constexpr auto isTreePath(void *) -> std::false_type │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:155 │ │ │ │ │ _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_:_:_f_i_r_s_t___t_y_p_e │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:21 │ │ │ │ │ +_D_u_n_e_:_:_f_i_r_s_t___t_y_p_e_<_ _T_0_,_ _T_._._._ _>_:_:_t_y_p_e │ │ │ │ │ +T0 type │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:26 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:33 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_:_:_v_a_l_u_e │ │ │ │ │ +static constexpr bool value │ │ │ │ │ +True if class T defines a NodeTag. │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:43 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_:_:_t_e_s_t │ │ │ │ │ +static yes test(NodeTag< X > *) │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_:_:_t_e_s_t │ │ │ │ │ +static no test(...) │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_:_:_y_e_s │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:34 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_:_:_y_e_s_:_:_d_u_m_m_y │ │ │ │ │ +char dummy[1] │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:34 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_:_:_n_o │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:35 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_:_:_n_o_:_:_d_u_m_m_y │ │ │ │ │ +char dummy[2] │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:35 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:48 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_:_:_t_e_s_t │ │ │ │ │ +static maybe< std::is_base_of< V, NodeTag< X > >::value > test(NodeTag< X > *a) │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_:_:_v_a_l_u_e │ │ │ │ │ +static constexpr bool value │ │ │ │ │ +True if class T defines a NodeTag of type V. │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:61 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_:_:_t_e_s_t │ │ │ │ │ +static no test(...) │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_:_:_m_a_y_b_e │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:50 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_:_:_m_a_y_b_e_:_:_d_u_m_m_y │ │ │ │ │ +char dummy[N+1] │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:50 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_:_:_y_e_s │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:51 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_:_:_y_e_s_:_:_d_u_m_m_y │ │ │ │ │ +char dummy[2] │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:51 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_:_:_n_o │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:52 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_:_:_n_o_:_:_d_u_m_m_y │ │ │ │ │ +char dummy[1] │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:52 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:66 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_:_:_t_e_s_t │ │ │ │ │ +static yes test(ImplementationTag< X > *) │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_:_:_t_e_s_t │ │ │ │ │ +static no test(...) │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_:_:_v_a_l_u_e │ │ │ │ │ +static constexpr bool value │ │ │ │ │ +True if class T defines an ImplementationTag. │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:76 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_:_:_y_e_s │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:67 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_:_:_y_e_s_:_:_d_u_m_m_y │ │ │ │ │ +char dummy[1] │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:67 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_:_:_n_o │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:68 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_:_:_n_o_:_:_d_u_m_m_y │ │ │ │ │ +char dummy[2] │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:68 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:81 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_:_:_t_e_s_t │ │ │ │ │ +static maybe< std::is_base_of< V, ImplementationTag< X > >::value > test │ │ │ │ │ +(ImplementationTag< X > *a) │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_:_:_t_e_s_t │ │ │ │ │ +static no test(...) │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_:_:_v_a_l_u_e │ │ │ │ │ +static constexpr bool value │ │ │ │ │ +True if class T defines an ImplementationTag of type V. │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:94 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_:_:_m_a_y_b_e │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:83 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_:_:_m_a_y_b_e_:_:_d_u_m_m_y │ │ │ │ │ +char dummy[N+1] │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:83 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_:_:_y_e_s │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:84 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_:_:_y_e_s_:_:_d_u_m_m_y │ │ │ │ │ +char dummy[2] │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:84 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_:_:_n_o │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:85 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_:_:_n_o_:_:_d_u_m_m_y │ │ │ │ │ +char dummy[1] │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:85 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_l_w_a_y_s_V_o_i_d │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:99 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_l_w_a_y_s_V_o_i_d_:_:_t_y_p_e │ │ │ │ │ +void type │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:100 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_e_t_a___f_u_n_c_t_i_o_n │ │ │ │ │ +Marker tag declaring a meta function. │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:123 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_l_a_z_y___e_v_a_l_u_a_t_e │ │ │ │ │ +Helper meta function to delay evaluation of F. │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:128 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_l_a_z_y___e_v_a_l_u_a_t_e_:_:_t_y_p_e │ │ │ │ │ +F::type type │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:129 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_l_a_z_y___i_d_e_n_t_i_t_y │ │ │ │ │ +Identity function. │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:135 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_l_a_z_y___i_d_e_n_t_i_t_y_:_:_t_y_p_e │ │ │ │ │ +F type │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:136 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_e_v_a_l_u_a_t_e___i_f___m_e_t_a___f_u_n_c_t_i_o_n │ │ │ │ │ +Meta function that evaluates its argument iff it inherits from meta_function. │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:142 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_e_v_a_l_u_a_t_e___i_f___m_e_t_a___f_u_n_c_t_i_o_n_:_:_t_y_p_e │ │ │ │ │ +std::conditional< std::is_base_of< meta_function, F >::value, lazy_evaluate< F │ │ │ │ │ +>, lazy_identity< F > >::type::type type │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:147 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_I_s_T_r_e_e_P_a_t_h │ │ │ │ │ +Check if type represents a tree path. │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:184 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00017.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: powercompositenodetransformationtemplates.hh File Reference │ │ │ │ +dune-typetree: treecontainer.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -71,44 +71,74 @@ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ Classes | │ │ │ │ -Namespaces
    │ │ │ │ -
    powercompositenodetransformationtemplates.hh File Reference
    │ │ │ │ +Namespaces | │ │ │ │ +Typedefs | │ │ │ │ +Functions
    │ │ │ │ +
    treecontainer.hh File Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ -
    #include <cstddef>
    │ │ │ │ -#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ +
    #include <type_traits>
    │ │ │ │ +#include <utility>
    │ │ │ │ +#include <functional>
    │ │ │ │ +#include <array>
    │ │ │ │ +#include <dune/common/indices.hh>
    │ │ │ │ +#include <dune/common/hybridutilities.hh>
    │ │ │ │ +#include <dune/common/rangeutilities.hh>
    │ │ │ │ +#include <dune/common/tuplevector.hh>
    │ │ │ │ +#include <dune/typetree/treepath.hh>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  Dune::TypeTree::GenericPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >
    class  Dune::TypeTree::Detail::ContainerFactory< LeafToValue >
     
    struct  Dune::TypeTree::GenericPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::result< TC >
    class  Dune::TypeTree::Detail::TreeContainerVectorBackend< Container >
     
    struct  Dune::TypeTree::GenericDynamicPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >
     
    struct  Dune::TypeTree::GenericDynamicPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::result< TC >
     
    struct  Dune::TypeTree::GenericCompositeNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >
     
    struct  Dune::TypeTree::GenericCompositeNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::result< TC >
    struct  Dune::TypeTree::Detail::LeafToDefaultConstructibleValue< LeafToValue >
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + │ │ │ │ + │ │ │ │ +

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
     
    namespace  Dune::TypeTree::Detail
     
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +

    │ │ │ │ +Typedefs

    template<class Value , class Tree >
    using Dune::TypeTree::UniformTreeContainer = std::decay_t< decltype(makeTreeContainer< Value >(std::declval< const Tree & >()))>
     Alias to container type generated by makeTreeContainer for given tree type and uniform value type.
     
    template<template< class Node > class LeafToValue, class Tree >
    using Dune::TypeTree::TreeContainer = std::decay_t< decltype(makeTreeContainer(std::declval< const Tree & >(), std::declval< Detail::LeafToDefaultConstructibleValue< LeafToValue > >()))>
     Alias to container type generated by makeTreeContainer for give tree type and when using LeafToValue to create values.
     
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │

    │ │ │ │ +Functions

    template<class Container >
    auto Dune::TypeTree::Detail::makeTreeContainerVectorBackend (Container &&container)
     
    template<class Tree , class LeafToValue >
    auto Dune::TypeTree::makeTreeContainer (const Tree &tree, LeafToValue &&leafToValue)
     Create container havin the same structure as the given tree.
     
    template<class Value , class Tree >
    auto Dune::TypeTree::makeTreeContainer (const Tree &tree)
     Create container havin the same structure as the given tree.
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,37 +1,62 @@ │ │ │ │ │ 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 │ │ │ │ │ -powercompositenodetransformationtemplates.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> │ │ │ │ │ +_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s │ │ │ │ │ +treecontainer.hh File Reference │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_e_e_p_a_t_h_._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_:_:_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ - _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ + class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_C_o_n_t_a_i_n_e_r_F_a_c_t_o_r_y_<_ _L_e_a_f_T_o_V_a_l_u_e_ _> │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ - _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _>_:_:_r_e_s_u_l_t_<_ _T_C_ _> │ │ │ │ │ + class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d_<_ _C_o_n_t_a_i_n_e_r_ _> │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_< │ │ │ │ │ - _S_o_u_r_c_e_N_o_d_e_,_ _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_< │ │ │ │ │ - _S_o_u_r_c_e_N_o_d_e_,_ _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _>_:_:_r_e_s_u_l_t_<_ _T_C_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_< │ │ │ │ │ - _S_o_u_r_c_e_N_o_d_e_,_ _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_< │ │ │ │ │ - _S_o_u_r_c_e_N_o_d_e_,_ _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _>_:_:_r_e_s_u_l_t_<_ _T_C_ _> │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_L_e_a_f_T_o_D_e_f_a_u_l_t_C_o_n_s_t_r_u_c_t_i_b_l_e_V_a_l_u_e_<_ _L_e_a_f_T_o_V_a_l_u_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_:_:_D_e_t_a_i_l │ │ │ │ │ +  │ │ │ │ │ +TTyyppeeddeeffss │ │ │ │ │ +template │ │ │ │ │ +using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_U_n_i_f_o_r_m_T_r_e_e_C_o_n_t_a_i_n_e_r = std::decay_t< decltype │ │ │ │ │ + (_m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r< Value >(std::declval< const Tree & >()))> │ │ │ │ │ +  Alias to container type generated by makeTreeContainer for given tree │ │ │ │ │ + type and uniform value type. │ │ │ │ │ +  │ │ │ │ │ +template class LeafToValue, class Tree > │ │ │ │ │ +using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r = std::decay_t< decltype(_m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r │ │ │ │ │ + (std::declval< const Tree & >(), std::declval< _D_e_t_a_i_l_:_: │ │ │ │ │ + _L_e_a_f_T_o_D_e_f_a_u_l_t_C_o_n_s_t_r_u_c_t_i_b_l_e_V_a_l_u_e< LeafToValue > >()))> │ │ │ │ │ +  Alias to container type generated by makeTreeContainer for give tree │ │ │ │ │ + type and when using LeafToValue to create values. │ │ │ │ │ +  │ │ │ │ │ +FFuunnccttiioonnss │ │ │ │ │ +template │ │ │ │ │ +auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d (Container │ │ │ │ │ + &&container) │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ +auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r (const Tree &tree, LeafToValue │ │ │ │ │ + &&leafToValue) │ │ │ │ │ +  Create container havin the same structure as the given tree. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ +auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r (const Tree &tree) │ │ │ │ │ +  Create container havin the same structure as the given tree. │ │ │ │ │ +  │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00017_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: powercompositenodetransformationtemplates.hh Source File │ │ │ │ +dune-typetree: treecontainer.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,91 +74,333 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -
    powercompositenodetransformationtemplates.hh
    │ │ │ │ +
    treecontainer.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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_POWERCOMPOSITENODETRANSFORMATIONTEMPLATES_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_POWERCOMPOSITENODETRANSFORMATIONTEMPLATES_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_TREECONTAINER_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_TREECONTAINER_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <cstddef>
    │ │ │ │ -
    10
    │ │ │ │ -
    11#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ -
    12
    │ │ │ │ -
    13namespace Dune {
    │ │ │ │ -
    14 namespace TypeTree {
    │ │ │ │ -
    15
    │ │ │ │ -
    21 template<typename SourceNode, typename Transformation, template<typename,typename,std::size_t> class TransformedNode>
    │ │ │ │ -
    │ │ │ │ -
    22 struct GenericPowerNodeTransformationTemplate
    │ │ │ │ -
    23 {
    │ │ │ │ -
    24 template<typename TC>
    │ │ │ │ -
    │ │ │ │ -
    25 struct result
    │ │ │ │ -
    26 {
    │ │ │ │ -
    27 typedef TransformedNode<SourceNode,TC,StaticDegree<SourceNode>::value> type;
    │ │ │ │ -
    28 };
    │ │ │ │ -
    │ │ │ │ -
    29 };
    │ │ │ │ -
    │ │ │ │ -
    30
    │ │ │ │ -
    31
    │ │ │ │ -
    32 template<typename SourceNode, typename Transformation, template<typename,typename> class TransformedNode>
    │ │ │ │ -
    │ │ │ │ -
    33 struct GenericDynamicPowerNodeTransformationTemplate
    │ │ │ │ -
    34 {
    │ │ │ │ -
    35 template<typename TC>
    │ │ │ │ -
    │ │ │ │ -
    36 struct result
    │ │ │ │ -
    37 {
    │ │ │ │ -
    38 typedef TransformedNode<SourceNode,TC> type;
    │ │ │ │ -
    39 };
    │ │ │ │ -
    │ │ │ │ -
    40 };
    │ │ │ │ -
    │ │ │ │ -
    41
    │ │ │ │ -
    42 template<typename SourceNode, typename Transformation, template<typename,typename...> class TransformedNode>
    │ │ │ │ -
    │ │ │ │ -
    43 struct GenericCompositeNodeTransformationTemplate
    │ │ │ │ -
    44 {
    │ │ │ │ -
    45 template<typename... TC>
    │ │ │ │ -
    │ │ │ │ -
    46 struct result
    │ │ │ │ -
    47 {
    │ │ │ │ -
    48 typedef TransformedNode<SourceNode,TC...> type;
    │ │ │ │ -
    49 };
    │ │ │ │ -
    │ │ │ │ -
    50 };
    │ │ │ │ -
    │ │ │ │ -
    51
    │ │ │ │ -
    53
    │ │ │ │ -
    54 } // namespace TypeTree
    │ │ │ │ -
    55} //namespace Dune
    │ │ │ │ -
    56
    │ │ │ │ -
    57#endif // DUNE_TYPETREE_POWERCOMPOSITENODETRANSFORMATIONTEMPLATES_HH
    │ │ │ │ - │ │ │ │ +
    9#include <type_traits>
    │ │ │ │ +
    10#include <utility>
    │ │ │ │ +
    11#include <functional>
    │ │ │ │ +
    12#include <array>
    │ │ │ │ +
    13
    │ │ │ │ +
    14#include <dune/common/indices.hh>
    │ │ │ │ +
    15#include <dune/common/hybridutilities.hh>
    │ │ │ │ +
    16#include <dune/common/rangeutilities.hh>
    │ │ │ │ +
    17#include <dune/common/tuplevector.hh>
    │ │ │ │ +
    18
    │ │ │ │ +
    19#include <dune/typetree/treepath.hh>
    │ │ │ │ +
    20
    │ │ │ │ +
    21namespace Dune {
    │ │ │ │ +
    22 namespace TypeTree {
    │ │ │ │ +
    23
    │ │ │ │ +
    24 namespace Detail {
    │ │ │ │ +
    25
    │ │ │ │ +
    26 /*
    │ │ │ │ +
    27 * \brief A factory class creating a hybrid container compatible with a type tree
    │ │ │ │ +
    28 *
    │ │ │ │ +
    29 * This class allows to create a nested hybrid container having the same structure
    │ │ │ │ +
    30 * as a given type tree. Power nodes are represented as std::array's while composite
    │ │ │ │ +
    31 * nodes are represented as Dune::TupleVector's. The stored values for the leaf nodes
    │ │ │ │ +
    32 * are creating using a given predicate. Once created, the factory provides an
    │ │ │ │ +
    33 * operator() creating the container for the tree given as argument.
    │ │ │ │ +
    34 *
    │ │ │ │ +
    35 * \tparam LeafToValue Type of a predicate that determines the stored values at the leafs
    │ │ │ │ +
    36 */
    │ │ │ │ +
    37 template<class LeafToValue>
    │ │ │ │ +
    │ │ │ │ +
    38 class ContainerFactory
    │ │ │ │ +
    39 {
    │ │ │ │ +
    40 template<class N>
    │ │ │ │ +
    41 using DynamicDegreeConcept = decltype((std::size_t(std::declval<N>().degree()), true));
    │ │ │ │ +
    42
    │ │ │ │ +
    43 template<class N>
    │ │ │ │ +
    44 using StaticDegreeConcept = decltype((std::integral_constant<std::size_t, N::degree()>{}, true));
    │ │ │ │ +
    45
    │ │ │ │ +
    46 template<class N>
    │ │ │ │ +
    47 using DynamicChildAccessConcept = decltype((std::declval<N>().child(0u), true));
    │ │ │ │ +
    48
    │ │ │ │ +
    49 public:
    │ │ │ │ +
    50
    │ │ │ │ +
    │ │ │ │ +
    58 ContainerFactory(LeafToValue leafToValue) :
    │ │ │ │ +
    59 leafToValue_(leafToValue)
    │ │ │ │ +
    60 {}
    │ │ │ │ +
    │ │ │ │ +
    61
    │ │ │ │ +
    62 template<class Node>
    │ │ │ │ +
    │ │ │ │ +
    63 auto operator()(const Node& node)
    │ │ │ │ +
    64 {
    │ │ │ │ +
    65 return (*this)(node, Dune::PriorityTag<5>{});
    │ │ │ │ +
    66 }
    │ │ │ │ +
    │ │ │ │ +
    67
    │ │ │ │ +
    68 private:
    │ │ │ │ +
    69
    │ │ │ │ +
    70 template<class Node,
    │ │ │ │ +
    71 std::enable_if_t<Node::isLeaf, bool> = true>
    │ │ │ │ +
    72 auto operator()(const Node& node, Dune::PriorityTag<4>)
    │ │ │ │ +
    73 {
    │ │ │ │ +
    74 return leafToValue_(node);
    │ │ │ │ +
    75 }
    │ │ │ │ +
    76
    │ │ │ │ +
    77 template<class Node,
    │ │ │ │ +
    78 StaticDegreeConcept<Node> = true,
    │ │ │ │ +
    79 DynamicChildAccessConcept<Node> = true>
    │ │ │ │ +
    80 auto operator()(const Node& node, Dune::PriorityTag<3>)
    │ │ │ │ +
    81 {
    │ │ │ │ +
    82 return Dune::unpackIntegerSequence([&](auto... indices) {
    │ │ │ │ +
    83 return std::array{(*this)(node.child(indices))...};
    │ │ │ │ +
    84 }, std::make_index_sequence<std::size_t(Node::degree())>());
    │ │ │ │ +
    85 }
    │ │ │ │ +
    86
    │ │ │ │ +
    87 template<class Node,
    │ │ │ │ +
    88 DynamicDegreeConcept<Node> = true,
    │ │ │ │ +
    89 DynamicChildAccessConcept<Node> = true>
    │ │ │ │ +
    90 auto operator()(const Node& node, Dune::PriorityTag<2>)
    │ │ │ │ +
    91 {
    │ │ │ │ +
    92 using TransformedChild = decltype((*this)(node.child(0)));
    │ │ │ │ +
    93 std::vector<TransformedChild> container;
    │ │ │ │ +
    94 container.reserve(node.degree());
    │ │ │ │ +
    95 for (std::size_t i = 0; i < node.degree(); ++i)
    │ │ │ │ +
    96 container.emplace_back((*this)(node.child(i)));
    │ │ │ │ +
    97 return container;
    │ │ │ │ +
    98 }
    │ │ │ │ +
    99
    │ │ │ │ +
    100 template<class Node,
    │ │ │ │ +
    101 StaticDegreeConcept<Node> = true>
    │ │ │ │ +
    102 auto operator()(const Node& node, Dune::PriorityTag<1>)
    │ │ │ │ +
    103 {
    │ │ │ │ +
    104 return Dune::unpackIntegerSequence([&](auto... indices) {
    │ │ │ │ +
    105 return Dune::makeTupleVector((*this)(node.child(indices))...);
    │ │ │ │ +
    106 }, std::make_index_sequence<std::size_t(Node::degree())>());
    │ │ │ │ +
    107 }
    │ │ │ │ +
    108
    │ │ │ │ +
    109 private:
    │ │ │ │ +
    110 LeafToValue leafToValue_;
    │ │ │ │ +
    111 };
    │ │ │ │ +
    │ │ │ │ +
    112
    │ │ │ │ +
    113
    │ │ │ │ +
    114 /*
    │ │ │ │ +
    115 * \brief Wrap nested container to provide a VectorBackend
    │ │ │ │ +
    116 */
    │ │ │ │ +
    117 template<class Container>
    │ │ │ │ +
    │ │ │ │ +
    118 class TreeContainerVectorBackend
    │ │ │ │ +
    119 {
    │ │ │ │ +
    120 template<class C>
    │ │ │ │ +
    121 static constexpr decltype(auto) accessByTreePath(C&& container, const HybridTreePath<>& path)
    │ │ │ │ +
    122 {
    │ │ │ │ +
    123 return container;
    │ │ │ │ +
    124 }
    │ │ │ │ +
    125
    │ │ │ │ +
    126 template<class C, class... T>
    │ │ │ │ +
    127 static constexpr decltype(auto) accessByTreePath(C&& container, const HybridTreePath<T...>& path)
    │ │ │ │ +
    128 {
    │ │ │ │ +
    129 auto head = path[Dune::Indices::_0];
    │ │ │ │ +
    130 auto tailPath = Dune::unpackIntegerSequence([&](auto... i){
    │ │ │ │ +
    131 return treePath(path[Dune::index_constant<i+1>{}]...);
    │ │ │ │ +
    132 }, std::make_index_sequence<sizeof...(T)-1>());
    │ │ │ │ +
    133 return accessByTreePath(container[head], tailPath);
    │ │ │ │ +
    134 }
    │ │ │ │ +
    135
    │ │ │ │ +
    136 template<class C, class Tree,
    │ │ │ │ +
    137 std::enable_if_t<Tree::isLeaf, bool> = true>
    │ │ │ │ +
    138 static void resizeImpl(C& /*container*/, const Tree& /*tree*/, Dune::PriorityTag<2>)
    │ │ │ │ +
    139 {
    │ │ │ │ +
    140 /* do nothing */
    │ │ │ │ +
    141 }
    │ │ │ │ +
    142
    │ │ │ │ +
    143 template<class C, class Tree,
    │ │ │ │ +
    144 class = decltype(std::declval<C>().resize(0u))>
    │ │ │ │ +
    145 static void resizeImpl(C& container, const Tree& tree, Dune::PriorityTag<1>)
    │ │ │ │ +
    146 {
    │ │ │ │ +
    147 container.resize(tree.degree());
    │ │ │ │ +
    148 Dune::Hybrid::forEach(Dune::range(tree.degree()), [&](auto i) {
    │ │ │ │ +
    149 resizeImpl(container[i], tree.child(i), Dune::PriorityTag<5>{});
    │ │ │ │ +
    150 });
    │ │ │ │ +
    151 }
    │ │ │ │ +
    152
    │ │ │ │ +
    153 template<class C, class Tree>
    │ │ │ │ +
    154 static void resizeImpl(C& container, const Tree& tree, Dune::PriorityTag<0>)
    │ │ │ │ +
    155 {
    │ │ │ │ +
    156 Dune::Hybrid::forEach(Dune::range(tree.degree()), [&](auto i) {
    │ │ │ │ +
    157 resizeImpl(container[i], tree.child(i), Dune::PriorityTag<5>{});
    │ │ │ │ +
    158 });
    │ │ │ │ +
    159 }
    │ │ │ │ +
    160
    │ │ │ │ +
    161 template<class T>
    │ │ │ │ +
    162 using TypeTreeConcept = decltype((
    │ │ │ │ +
    163 std::declval<T>().degree(),
    │ │ │ │ +
    164 T::isLeaf,
    │ │ │ │ +
    165 T::isPower,
    │ │ │ │ +
    166 T::isComposite,
    │ │ │ │ +
    167 true));
    │ │ │ │ +
    168
    │ │ │ │ +
    169 public:
    │ │ │ │ +
    │ │ │ │ +
    171 TreeContainerVectorBackend(Container&& container) :
    │ │ │ │ +
    172 container_(std::move(container))
    │ │ │ │ +
    173 {}
    │ │ │ │ +
    │ │ │ │ +
    174
    │ │ │ │ +
    176 template <class Tree, TypeTreeConcept<Tree> = true>
    │ │ │ │ +
    │ │ │ │ +
    177 TreeContainerVectorBackend(const Tree& tree) :
    │ │ │ │ +
    178 TreeContainerVectorBackend()
    │ │ │ │ +
    179 {
    │ │ │ │ +
    180 this->resize(tree);
    │ │ │ │ +
    181 }
    │ │ │ │ +
    │ │ │ │ +
    182
    │ │ │ │ +
    184 template <class C = Container,
    │ │ │ │ +
    185 std::enable_if_t<std::is_default_constructible_v<C>, bool> = true>
    │ │ │ │ +
    │ │ │ │ +
    186 TreeContainerVectorBackend() :
    │ │ │ │ +
    187 container_()
    │ │ │ │ +
    188 {}
    │ │ │ │ +
    │ │ │ │ +
    189
    │ │ │ │ +
    190 template<class... T>
    │ │ │ │ +
    │ │ │ │ +
    191 decltype(auto) operator[](const HybridTreePath<T...>& path) const
    │ │ │ │ +
    192 {
    │ │ │ │ +
    193 return accessByTreePath(container_, path);
    │ │ │ │ +
    194 }
    │ │ │ │ +
    │ │ │ │ +
    195
    │ │ │ │ +
    196 template<class... T>
    │ │ │ │ +
    │ │ │ │ +
    197 decltype(auto) operator[](const HybridTreePath<T...>& path)
    │ │ │ │ +
    198 {
    │ │ │ │ +
    199 return accessByTreePath(container_, path);
    │ │ │ │ +
    200 }
    │ │ │ │ +
    │ │ │ │ +
    201
    │ │ │ │ +
    203 template<class Tree, TypeTreeConcept<Tree> = true>
    │ │ │ │ +
    │ │ │ │ +
    204 void resize(const Tree& tree)
    │ │ │ │ +
    205 {
    │ │ │ │ +
    206 resizeImpl(container_, tree, Dune::PriorityTag<5>{});
    │ │ │ │ +
    207 }
    │ │ │ │ +
    │ │ │ │ +
    208
    │ │ │ │ +
    │ │ │ │ +
    209 const Container& data() const
    │ │ │ │ +
    210 {
    │ │ │ │ +
    211 return container_;
    │ │ │ │ +
    212 }
    │ │ │ │ +
    │ │ │ │ +
    213
    │ │ │ │ +
    │ │ │ │ +
    214 Container& data()
    │ │ │ │ +
    215 {
    │ │ │ │ +
    216 return container_;
    │ │ │ │ +
    217 }
    │ │ │ │ +
    │ │ │ │ +
    218
    │ │ │ │ +
    219 private:
    │ │ │ │ +
    220 Container container_;
    │ │ │ │ +
    221 };
    │ │ │ │ +
    │ │ │ │ +
    222
    │ │ │ │ +
    223 template<class Container>
    │ │ │ │ +
    │ │ │ │ +
    224 auto makeTreeContainerVectorBackend(Container&& container)
    │ │ │ │ +
    225 {
    │ │ │ │ +
    226 return TreeContainerVectorBackend<std::decay_t<Container>>(std::forward<Container>(container));
    │ │ │ │ +
    227 }
    │ │ │ │ +
    │ │ │ │ +
    228
    │ │ │ │ +
    229 /*
    │ │ │ │ +
    230 * \brief A simple lambda for creating default constructible values from a node
    │ │ │ │ +
    231 *
    │ │ │ │ +
    232 * This simply returns LeafToValue<Node>{} for a given Node. It's needed
    │ │ │ │ +
    233 * because using a lambda expression in a using declaration is not allowed
    │ │ │ │ +
    234 * because it's an unevaluated context.
    │ │ │ │ +
    235 */
    │ │ │ │ +
    236 template<template<class Node> class LeafToValue>
    │ │ │ │ +
    │ │ │ │ +
    237 struct LeafToDefaultConstructibleValue
    │ │ │ │ +
    238 {
    │ │ │ │ +
    239 template<class Node>
    │ │ │ │ +
    │ │ │ │ +
    240 auto operator()(const Node& node) const
    │ │ │ │ +
    241 {
    │ │ │ │ +
    242 return LeafToValue<Node>{};
    │ │ │ │ +
    243 }
    │ │ │ │ +
    │ │ │ │ +
    244 };
    │ │ │ │ +
    │ │ │ │ +
    245
    │ │ │ │ +
    246 } // namespace Detail
    │ │ │ │ +
    247
    │ │ │ │ +
    267 template<class Tree, class LeafToValue>
    │ │ │ │ +
    │ │ │ │ +
    268 auto makeTreeContainer(const Tree& tree, LeafToValue&& leafToValue)
    │ │ │ │ +
    269 {
    │ │ │ │ +
    270 auto f = std::ref(leafToValue);
    │ │ │ │ +
    271 auto factory = Detail::ContainerFactory<decltype(f)>(f);
    │ │ │ │ +
    272 return Detail::makeTreeContainerVectorBackend(factory(tree));
    │ │ │ │ +
    273 }
    │ │ │ │ +
    │ │ │ │ +
    274
    │ │ │ │ +
    290 template<class Value, class Tree>
    │ │ │ │ +
    │ │ │ │ +
    291 auto makeTreeContainer(const Tree& tree)
    │ │ │ │ +
    292 {
    │ │ │ │ +
    293 return makeTreeContainer(tree, [](const auto&) {return Value{};});
    │ │ │ │ +
    294 }
    │ │ │ │ +
    │ │ │ │ +
    295
    │ │ │ │ +
    299 template<class Value, class Tree>
    │ │ │ │ +
    300 using UniformTreeContainer = std::decay_t<decltype(makeTreeContainer<Value>(std::declval<const Tree&>()))>;
    │ │ │ │ +
    301
    │ │ │ │ +
    305 template<template<class Node> class LeafToValue, class Tree>
    │ │ │ │ +
    306 using TreeContainer = std::decay_t<decltype(makeTreeContainer(std::declval<const Tree&>(), std::declval<Detail::LeafToDefaultConstructibleValue<LeafToValue>>()))>;
    │ │ │ │ +
    307
    │ │ │ │ +
    309
    │ │ │ │ +
    310 } // namespace TypeTree
    │ │ │ │ +
    311} //namespace Dune
    │ │ │ │ +
    312
    │ │ │ │ +
    313#endif // DUNE_TYPETREE_TREECONTAINER_HH
    │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::makeTreeContainer
    auto makeTreeContainer(const Tree &tree, LeafToValue &&leafToValue)
    Create container havin the same structure as the given tree.
    Definition treecontainer.hh:268
    │ │ │ │ +
    Dune::TypeTree::UniformTreeContainer
    std::decay_t< decltype(makeTreeContainer< Value >(std::declval< const Tree & >()))> UniformTreeContainer
    Alias to container type generated by makeTreeContainer for given tree type and uniform value type.
    Definition treecontainer.hh:300
    │ │ │ │ +
    Dune::TypeTree::TreeContainer
    std::decay_t< decltype(makeTreeContainer(std::declval< const Tree & >(), std::declval< Detail::LeafToDefaultConstructibleValue< LeafToValue > >()))> TreeContainer
    Alias to container type generated by makeTreeContainer for give tree type and when using LeafToValue ...
    Definition treecontainer.hh:306
    │ │ │ │ +
    Dune::TypeTree::degree
    std::size_t degree(const Node &node)
    Returns the degree of node as run time information.
    Definition nodeinterface.hh:79
    │ │ │ │ +
    Dune::TypeTree::treePath
    constexpr auto treePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:326
    │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::GenericPowerNodeTransformationTemplate
    Definition powercompositenodetransformationtemplates.hh:23
    │ │ │ │ -
    Dune::TypeTree::GenericPowerNodeTransformationTemplate::result
    Definition powercompositenodetransformationtemplates.hh:26
    │ │ │ │ -
    Dune::TypeTree::GenericPowerNodeTransformationTemplate::result::type
    TransformedNode< SourceNode, TC, StaticDegree< SourceNode >::value > type
    Definition powercompositenodetransformationtemplates.hh:27
    │ │ │ │ -
    Dune::TypeTree::GenericDynamicPowerNodeTransformationTemplate
    Definition powercompositenodetransformationtemplates.hh:34
    │ │ │ │ -
    Dune::TypeTree::GenericDynamicPowerNodeTransformationTemplate::result
    Definition powercompositenodetransformationtemplates.hh:37
    │ │ │ │ -
    Dune::TypeTree::GenericDynamicPowerNodeTransformationTemplate::result::type
    TransformedNode< SourceNode, TC > type
    Definition powercompositenodetransformationtemplates.hh:38
    │ │ │ │ -
    Dune::TypeTree::GenericCompositeNodeTransformationTemplate
    Definition powercompositenodetransformationtemplates.hh:44
    │ │ │ │ -
    Dune::TypeTree::GenericCompositeNodeTransformationTemplate::result
    Definition powercompositenodetransformationtemplates.hh:47
    │ │ │ │ -
    Dune::TypeTree::GenericCompositeNodeTransformationTemplate::result::type
    TransformedNode< SourceNode, TC... > type
    Definition powercompositenodetransformationtemplates.hh:48
    │ │ │ │ +
    Dune::TypeTree::Detail::makeTreeContainerVectorBackend
    auto makeTreeContainerVectorBackend(Container &&container)
    Definition treecontainer.hh:224
    │ │ │ │ +
    Dune::TypeTree::Detail::ContainerFactory
    Definition treecontainer.hh:39
    │ │ │ │ +
    Dune::TypeTree::Detail::ContainerFactory::operator()
    auto operator()(const Node &node)
    Definition treecontainer.hh:63
    │ │ │ │ +
    Dune::TypeTree::Detail::ContainerFactory::ContainerFactory
    ContainerFactory(LeafToValue leafToValue)
    Create ContainerFactory.
    Definition treecontainer.hh:58
    │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::Detail::TreeContainerVectorBackend::resize
    void resize(const Tree &tree)
    Resize the (nested) container depending on the degree of the tree nodes.
    Definition treecontainer.hh:204
    │ │ │ │ +
    Dune::TypeTree::Detail::TreeContainerVectorBackend::data
    Container & data()
    Definition treecontainer.hh:214
    │ │ │ │ +
    Dune::TypeTree::Detail::TreeContainerVectorBackend::data
    const Container & data() const
    Definition treecontainer.hh:209
    │ │ │ │ +
    Dune::TypeTree::Detail::TreeContainerVectorBackend::TreeContainerVectorBackend
    TreeContainerVectorBackend(Container &&container)
    Move the passed container into the internal storage.
    Definition treecontainer.hh:171
    │ │ │ │ +
    Dune::TypeTree::Detail::TreeContainerVectorBackend::TreeContainerVectorBackend
    TreeContainerVectorBackend()
    Default constructor. The stored container might need to be resized before usage.
    Definition treecontainer.hh:186
    │ │ │ │ +
    Dune::TypeTree::Detail::TreeContainerVectorBackend::TreeContainerVectorBackend
    TreeContainerVectorBackend(const Tree &tree)
    Default construct the container and perform a resize depending on the tree-node degrees.
    Definition treecontainer.hh:177
    │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::Detail::LeafToDefaultConstructibleValue::operator()
    auto operator()(const Node &node) const
    Definition treecontainer.hh:240
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath
    A hybrid version of TreePath that supports both compile time and run time indices.
    Definition treepath.hh:158
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,90 +1,367 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -powercompositenodetransformationtemplates.hh │ │ │ │ │ +treecontainer.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_POWERCOMPOSITENODETRANSFORMATIONTEMPLATES_HH │ │ │ │ │ -7#define DUNE_TYPETREE_POWERCOMPOSITENODETRANSFORMATIONTEMPLATES_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_TREECONTAINER_HH │ │ │ │ │ +7#define DUNE_TYPETREE_TREECONTAINER_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include │ │ │ │ │ -10 │ │ │ │ │ -11#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> │ │ │ │ │ -12 │ │ │ │ │ -13namespace _D_u_n_e { │ │ │ │ │ -14 namespace TypeTree { │ │ │ │ │ -15 │ │ │ │ │ -21 template class TransformedNode> │ │ │ │ │ -_2_2 struct _G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e │ │ │ │ │ -23 { │ │ │ │ │ -24 template │ │ │ │ │ -_2_5 struct _r_e_s_u_l_t │ │ │ │ │ -26 { │ │ │ │ │ -_2_7 typedef TransformedNode::value> _t_y_p_e; │ │ │ │ │ -28 }; │ │ │ │ │ -29 }; │ │ │ │ │ -30 │ │ │ │ │ -31 │ │ │ │ │ -32 template class TransformedNode> │ │ │ │ │ -_3_3 struct _G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e │ │ │ │ │ -34 { │ │ │ │ │ -35 template │ │ │ │ │ -_3_6 struct _r_e_s_u_l_t │ │ │ │ │ -37 { │ │ │ │ │ -_3_8 typedef TransformedNode _t_y_p_e; │ │ │ │ │ -39 }; │ │ │ │ │ -40 }; │ │ │ │ │ -41 │ │ │ │ │ -42 template class TransformedNode> │ │ │ │ │ -_4_3 struct _G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e │ │ │ │ │ -44 { │ │ │ │ │ -45 template │ │ │ │ │ -_4_6 struct _r_e_s_u_l_t │ │ │ │ │ -47 { │ │ │ │ │ -_4_8 typedef TransformedNode _t_y_p_e; │ │ │ │ │ -49 }; │ │ │ │ │ -50 }; │ │ │ │ │ -51 │ │ │ │ │ -53 │ │ │ │ │ -54 } // namespace TypeTree │ │ │ │ │ -55} //namespace Dune │ │ │ │ │ -56 │ │ │ │ │ -57#endif // DUNE_TYPETREE_POWERCOMPOSITENODETRANSFORMATIONTEMPLATES_HH │ │ │ │ │ -_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h │ │ │ │ │ +9#include │ │ │ │ │ +10#include │ │ │ │ │ +11#include │ │ │ │ │ +12#include │ │ │ │ │ +13 │ │ │ │ │ +14#include │ │ │ │ │ +15#include │ │ │ │ │ +16#include │ │ │ │ │ +17#include │ │ │ │ │ +18 │ │ │ │ │ +19#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_e_e_p_a_t_h_._h_h> │ │ │ │ │ +20 │ │ │ │ │ +21namespace _D_u_n_e { │ │ │ │ │ +22 namespace TypeTree { │ │ │ │ │ +23 │ │ │ │ │ +24 namespace Detail { │ │ │ │ │ +25 │ │ │ │ │ +26 /* │ │ │ │ │ +27 * \brief A factory class creating a hybrid container compatible with a type │ │ │ │ │ +tree │ │ │ │ │ +28 * │ │ │ │ │ +29 * This class allows to create a nested hybrid container having the same │ │ │ │ │ +structure │ │ │ │ │ +30 * as a given type tree. Power nodes are represented as std::array's while │ │ │ │ │ +composite │ │ │ │ │ +31 * nodes are represented as Dune::TupleVector's. The stored values for the │ │ │ │ │ +leaf nodes │ │ │ │ │ +32 * are creating using a given predicate. Once created, the factory provides │ │ │ │ │ +an │ │ │ │ │ +33 * operator() creating the container for the tree given as argument. │ │ │ │ │ +34 * │ │ │ │ │ +35 * \tparam LeafToValue Type of a predicate that determines the stored values │ │ │ │ │ +at the leafs │ │ │ │ │ +36 */ │ │ │ │ │ +37 template │ │ │ │ │ +_3_8 class _C_o_n_t_a_i_n_e_r_F_a_c_t_o_r_y │ │ │ │ │ +39 { │ │ │ │ │ +40 template │ │ │ │ │ +41 using DynamicDegreeConcept = decltype((std::size_t(std::declval()._d_e_g_r_e_e │ │ │ │ │ +()), true)); │ │ │ │ │ +42 │ │ │ │ │ +43 template │ │ │ │ │ +44 using StaticDegreeConcept = decltype((std::integral_constant{}, true)); │ │ │ │ │ +45 │ │ │ │ │ +46 template │ │ │ │ │ +47 using DynamicChildAccessConcept = decltype((std::declval().child(0u), │ │ │ │ │ +true)); │ │ │ │ │ +48 │ │ │ │ │ +49 public: │ │ │ │ │ +50 │ │ │ │ │ +_5_8 _C_o_n_t_a_i_n_e_r_F_a_c_t_o_r_y(LeafToValue leafToValue) : │ │ │ │ │ +59 leafToValue_(leafToValue) │ │ │ │ │ +60 {} │ │ │ │ │ +61 │ │ │ │ │ +62 template │ │ │ │ │ +_6_3 auto _o_p_e_r_a_t_o_r_(_)(const Node& node) │ │ │ │ │ +64 { │ │ │ │ │ +65 return (*this)(node, Dune::PriorityTag<5>{}); │ │ │ │ │ +66 } │ │ │ │ │ +67 │ │ │ │ │ +68 private: │ │ │ │ │ +69 │ │ │ │ │ +70 template = true> │ │ │ │ │ +72 auto _o_p_e_r_a_t_o_r_(_)(const Node& node, Dune::PriorityTag<4>) │ │ │ │ │ +73 { │ │ │ │ │ +74 return leafToValue_(node); │ │ │ │ │ +75 } │ │ │ │ │ +76 │ │ │ │ │ +77 template = true, │ │ │ │ │ +79 DynamicChildAccessConcept = true> │ │ │ │ │ +80 auto _o_p_e_r_a_t_o_r_(_)(const Node& node, Dune::PriorityTag<3>) │ │ │ │ │ +81 { │ │ │ │ │ +82 return Dune::unpackIntegerSequence([&](auto... indices) { │ │ │ │ │ +83 return std::array{(*this)(node.child(indices))...}; │ │ │ │ │ +84 }, std::make_index_sequence()); │ │ │ │ │ +85 } │ │ │ │ │ +86 │ │ │ │ │ +87 template = true, │ │ │ │ │ +89 DynamicChildAccessConcept = true> │ │ │ │ │ +90 auto _o_p_e_r_a_t_o_r_(_)(const Node& node, Dune::PriorityTag<2>) │ │ │ │ │ +91 { │ │ │ │ │ +92 using TransformedChild = decltype((*this)(node.child(0))); │ │ │ │ │ +93 std::vector container; │ │ │ │ │ +94 container.reserve(node.degree()); │ │ │ │ │ +95 for (std::size_t i = 0; i < node.degree(); ++i) │ │ │ │ │ +96 container.emplace_back((*this)(node.child(i))); │ │ │ │ │ +97 return container; │ │ │ │ │ +98 } │ │ │ │ │ +99 │ │ │ │ │ +100 template = true> │ │ │ │ │ +102 auto _o_p_e_r_a_t_o_r_(_)(const Node& node, Dune::PriorityTag<1>) │ │ │ │ │ +103 { │ │ │ │ │ +104 return Dune::unpackIntegerSequence([&](auto... indices) { │ │ │ │ │ +105 return Dune::makeTupleVector((*this)(node.child(indices))...); │ │ │ │ │ +106 }, std::make_index_sequence()); │ │ │ │ │ +107 } │ │ │ │ │ +108 │ │ │ │ │ +109 private: │ │ │ │ │ +110 LeafToValue leafToValue_; │ │ │ │ │ +111 }; │ │ │ │ │ +112 │ │ │ │ │ +113 │ │ │ │ │ +114 /* │ │ │ │ │ +115 * \brief Wrap nested container to provide a VectorBackend │ │ │ │ │ +116 */ │ │ │ │ │ +117 template │ │ │ │ │ +_1_1_8 class _T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d │ │ │ │ │ +119 { │ │ │ │ │ +120 template │ │ │ │ │ +121 static constexpr decltype(auto) accessByTreePath(C&& container, const │ │ │ │ │ +_H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_>& path) │ │ │ │ │ +122 { │ │ │ │ │ +123 return container; │ │ │ │ │ +124 } │ │ │ │ │ +125 │ │ │ │ │ +126 template │ │ │ │ │ +127 static constexpr decltype(auto) accessByTreePath(C&& container, const │ │ │ │ │ +_H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& path) │ │ │ │ │ +128 { │ │ │ │ │ +129 auto head = path[Dune::Indices::_0]; │ │ │ │ │ +130 auto tailPath = Dune::unpackIntegerSequence([&](auto... i){ │ │ │ │ │ +131 return _t_r_e_e_P_a_t_h(path[Dune::index_constant{}]...); │ │ │ │ │ +132 }, std::make_index_sequence()); │ │ │ │ │ +133 return accessByTreePath(container[head], tailPath); │ │ │ │ │ +134 } │ │ │ │ │ +135 │ │ │ │ │ +136 template = true> │ │ │ │ │ +138 static void resizeImpl(C& /*container*/, const Tree& /*tree*/, Dune:: │ │ │ │ │ +PriorityTag<2>) │ │ │ │ │ +139 { │ │ │ │ │ +140 /* do nothing */ │ │ │ │ │ +141 } │ │ │ │ │ +142 │ │ │ │ │ +143 template().resize(0u))> │ │ │ │ │ +145 static void resizeImpl(C& container, const Tree& tree, Dune:: │ │ │ │ │ +PriorityTag<1>) │ │ │ │ │ +146 { │ │ │ │ │ +147 container.resize(tree.degree()); │ │ │ │ │ +148 Dune::Hybrid::forEach(Dune::range(tree.degree()), [&](auto i) { │ │ │ │ │ +149 resizeImpl(container[i], tree.child(i), Dune::PriorityTag<5>{}); │ │ │ │ │ +150 }); │ │ │ │ │ +151 } │ │ │ │ │ +152 │ │ │ │ │ +153 template │ │ │ │ │ +154 static void resizeImpl(C& container, const Tree& tree, Dune:: │ │ │ │ │ +PriorityTag<0>) │ │ │ │ │ +155 { │ │ │ │ │ +156 Dune::Hybrid::forEach(Dune::range(tree.degree()), [&](auto i) { │ │ │ │ │ +157 resizeImpl(container[i], tree.child(i), Dune::PriorityTag<5>{}); │ │ │ │ │ +158 }); │ │ │ │ │ +159 } │ │ │ │ │ +160 │ │ │ │ │ +161 template │ │ │ │ │ +162 using TypeTreeConcept = decltype(( │ │ │ │ │ +163 std::declval().degree(), │ │ │ │ │ +164 T::isLeaf, │ │ │ │ │ +165 T::isPower, │ │ │ │ │ +166 T::isComposite, │ │ │ │ │ +167 true)); │ │ │ │ │ +168 │ │ │ │ │ +169 public: │ │ │ │ │ +_1_7_1 _T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d(Container&& container) : │ │ │ │ │ +172 container_(std::move(container)) │ │ │ │ │ +173 {} │ │ │ │ │ +174 │ │ │ │ │ +176 template = true> │ │ │ │ │ +_1_7_7 _T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d(const Tree& tree) : │ │ │ │ │ +178 _T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d() │ │ │ │ │ +179 { │ │ │ │ │ +180 this->resize(tree); │ │ │ │ │ +181 } │ │ │ │ │ +182 │ │ │ │ │ +184 template , bool> = true> │ │ │ │ │ +_1_8_6 _T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d() : │ │ │ │ │ +187 container_() │ │ │ │ │ +188 {} │ │ │ │ │ +189 │ │ │ │ │ +190 template │ │ │ │ │ +_1_9_1 decltype(auto) operator[](const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& path) const │ │ │ │ │ +192 { │ │ │ │ │ +193 return accessByTreePath(container_, path); │ │ │ │ │ +194 } │ │ │ │ │ +195 │ │ │ │ │ +196 template │ │ │ │ │ +_1_9_7 decltype(auto) operator[](const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& path) │ │ │ │ │ +198 { │ │ │ │ │ +199 return accessByTreePath(container_, path); │ │ │ │ │ +200 } │ │ │ │ │ +201 │ │ │ │ │ +203 template = true> │ │ │ │ │ +_2_0_4 void _r_e_s_i_z_e(const Tree& tree) │ │ │ │ │ +205 { │ │ │ │ │ +206 resizeImpl(container_, tree, Dune::PriorityTag<5>{}); │ │ │ │ │ +207 } │ │ │ │ │ +208 │ │ │ │ │ +_2_0_9 const Container& _d_a_t_a() const │ │ │ │ │ +210 { │ │ │ │ │ +211 return container_; │ │ │ │ │ +212 } │ │ │ │ │ +213 │ │ │ │ │ +_2_1_4 Container& _d_a_t_a() │ │ │ │ │ +215 { │ │ │ │ │ +216 return container_; │ │ │ │ │ +217 } │ │ │ │ │ +218 │ │ │ │ │ +219 private: │ │ │ │ │ +220 Container container_; │ │ │ │ │ +221 }; │ │ │ │ │ +222 │ │ │ │ │ +223 template │ │ │ │ │ +_2_2_4 auto _m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d(Container&& container) │ │ │ │ │ +225 { │ │ │ │ │ +226 return _T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d_<_s_t_d_:_:_d_e_c_a_y___t_<_C_o_n_t_a_i_n_e_r_>>(std:: │ │ │ │ │ +forward(container)); │ │ │ │ │ +227 } │ │ │ │ │ +228 │ │ │ │ │ +229 /* │ │ │ │ │ +230 * \brief A simple lambda for creating default constructible values from a │ │ │ │ │ +node │ │ │ │ │ +231 * │ │ │ │ │ +232 * This simply returns LeafToValue{} for a given Node. It's needed │ │ │ │ │ +233 * because using a lambda expression in a using declaration is not allowed │ │ │ │ │ +234 * because it's an unevaluated context. │ │ │ │ │ +235 */ │ │ │ │ │ +236 template class LeafToValue> │ │ │ │ │ +_2_3_7 struct _L_e_a_f_T_o_D_e_f_a_u_l_t_C_o_n_s_t_r_u_c_t_i_b_l_e_V_a_l_u_e │ │ │ │ │ +238 { │ │ │ │ │ +239 template │ │ │ │ │ +_2_4_0 auto _o_p_e_r_a_t_o_r_(_)(const Node& node) const │ │ │ │ │ +241 { │ │ │ │ │ +242 return LeafToValue{}; │ │ │ │ │ +243 } │ │ │ │ │ +244 }; │ │ │ │ │ +245 │ │ │ │ │ +246 } // namespace Detail │ │ │ │ │ +247 │ │ │ │ │ +267 template │ │ │ │ │ +_2_6_8 auto _m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r(const Tree& tree, LeafToValue&& leafToValue) │ │ │ │ │ +269 { │ │ │ │ │ +270 auto f = std::ref(leafToValue); │ │ │ │ │ +271 auto factory = _D_e_t_a_i_l_:_:_C_o_n_t_a_i_n_e_r_F_a_c_t_o_r_y_<_d_e_c_l_t_y_p_e_(_f_)_>(f); │ │ │ │ │ +272 return Detail::makeTreeContainerVectorBackend(factory(tree)); │ │ │ │ │ +273 } │ │ │ │ │ +274 │ │ │ │ │ +290 template │ │ │ │ │ +_2_9_1 auto _m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r(const Tree& tree) │ │ │ │ │ +292 { │ │ │ │ │ +293 return _m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r(tree, [](const auto&) {return Value{};}); │ │ │ │ │ +294 } │ │ │ │ │ +295 │ │ │ │ │ +299 template │ │ │ │ │ +_3_0_0 using _U_n_i_f_o_r_m_T_r_e_e_C_o_n_t_a_i_n_e_r = std::decay_t │ │ │ │ │ +(std::declval()))>; │ │ │ │ │ +301 │ │ │ │ │ +305 template class LeafToValue, class Tree> │ │ │ │ │ +_3_0_6 using _T_r_e_e_C_o_n_t_a_i_n_e_r = std::decay_t(), std::declval>()))>; │ │ │ │ │ +307 │ │ │ │ │ +309 │ │ │ │ │ +310 } // namespace TypeTree │ │ │ │ │ +311} //namespace Dune │ │ │ │ │ +312 │ │ │ │ │ +313#endif // DUNE_TYPETREE_TREECONTAINER_HH │ │ │ │ │ +_t_r_e_e_p_a_t_h_._h_h │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r │ │ │ │ │ +auto makeTreeContainer(const Tree &tree, LeafToValue &&leafToValue) │ │ │ │ │ +Create container havin the same structure as the given tree. │ │ │ │ │ +DDeeffiinniittiioonn treecontainer.hh:268 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_U_n_i_f_o_r_m_T_r_e_e_C_o_n_t_a_i_n_e_r │ │ │ │ │ +std::decay_t< decltype(makeTreeContainer< Value >(std::declval< const Tree & > │ │ │ │ │ +()))> UniformTreeContainer │ │ │ │ │ +Alias to container type generated by makeTreeContainer for given tree type and │ │ │ │ │ +uniform value type. │ │ │ │ │ +DDeeffiinniittiioonn treecontainer.hh:300 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r │ │ │ │ │ +std::decay_t< decltype(makeTreeContainer(std::declval< const Tree & >(), std:: │ │ │ │ │ +declval< Detail::LeafToDefaultConstructibleValue< LeafToValue > >()))> │ │ │ │ │ +TreeContainer │ │ │ │ │ +Alias to container type generated by makeTreeContainer for give tree type and │ │ │ │ │ +when using LeafToValue ... │ │ │ │ │ +DDeeffiinniittiioonn treecontainer.hh:306 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_d_e_g_r_e_e │ │ │ │ │ +std::size_t degree(const Node &node) │ │ │ │ │ +Returns the degree of node as run time information. │ │ │ │ │ +DDeeffiinniittiioonn nodeinterface.hh:79 │ │ │ │ │ +_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_:_:_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e │ │ │ │ │ -DDeeffiinniittiioonn powercompositenodetransformationtemplates.hh:23 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_:_:_r_e_s_u_l_t │ │ │ │ │ -DDeeffiinniittiioonn powercompositenodetransformationtemplates.hh:26 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_:_:_r_e_s_u_l_t_:_:_t_y_p_e │ │ │ │ │ -TransformedNode< SourceNode, TC, StaticDegree< SourceNode >::value > type │ │ │ │ │ -DDeeffiinniittiioonn powercompositenodetransformationtemplates.hh:27 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e │ │ │ │ │ -DDeeffiinniittiioonn powercompositenodetransformationtemplates.hh:34 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_:_:_r_e_s_u_l_t │ │ │ │ │ -DDeeffiinniittiioonn powercompositenodetransformationtemplates.hh:37 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_:_:_r_e_s_u_l_t_:_:_t_y_p_e │ │ │ │ │ -TransformedNode< SourceNode, TC > type │ │ │ │ │ -DDeeffiinniittiioonn powercompositenodetransformationtemplates.hh:38 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e │ │ │ │ │ -DDeeffiinniittiioonn powercompositenodetransformationtemplates.hh:44 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_:_:_r_e_s_u_l_t │ │ │ │ │ -DDeeffiinniittiioonn powercompositenodetransformationtemplates.hh:47 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_:_:_r_e_s_u_l_t_:_:_t_y_p_e │ │ │ │ │ -TransformedNode< SourceNode, TC... > type │ │ │ │ │ -DDeeffiinniittiioonn powercompositenodetransformationtemplates.hh:48 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_m_a_k_e_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d │ │ │ │ │ +auto makeTreeContainerVectorBackend(Container &&container) │ │ │ │ │ +DDeeffiinniittiioonn treecontainer.hh:224 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_C_o_n_t_a_i_n_e_r_F_a_c_t_o_r_y │ │ │ │ │ +DDeeffiinniittiioonn treecontainer.hh:39 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_C_o_n_t_a_i_n_e_r_F_a_c_t_o_r_y_:_:_o_p_e_r_a_t_o_r_(_) │ │ │ │ │ +auto operator()(const Node &node) │ │ │ │ │ +DDeeffiinniittiioonn treecontainer.hh:63 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_C_o_n_t_a_i_n_e_r_F_a_c_t_o_r_y_:_:_C_o_n_t_a_i_n_e_r_F_a_c_t_o_r_y │ │ │ │ │ +ContainerFactory(LeafToValue leafToValue) │ │ │ │ │ +Create ContainerFactory. │ │ │ │ │ +DDeeffiinniittiioonn treecontainer.hh:58 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d │ │ │ │ │ +DDeeffiinniittiioonn treecontainer.hh:119 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d_:_:_r_e_s_i_z_e │ │ │ │ │ +void resize(const Tree &tree) │ │ │ │ │ +Resize the (nested) container depending on the degree of the tree nodes. │ │ │ │ │ +DDeeffiinniittiioonn treecontainer.hh:204 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d_:_:_d_a_t_a │ │ │ │ │ +Container & data() │ │ │ │ │ +DDeeffiinniittiioonn treecontainer.hh:214 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d_:_:_d_a_t_a │ │ │ │ │ +const Container & data() const │ │ │ │ │ +DDeeffiinniittiioonn treecontainer.hh:209 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d │ │ │ │ │ +TreeContainerVectorBackend(Container &&container) │ │ │ │ │ +Move the passed container into the internal storage. │ │ │ │ │ +DDeeffiinniittiioonn treecontainer.hh:171 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d │ │ │ │ │ +TreeContainerVectorBackend() │ │ │ │ │ +Default constructor. The stored container might need to be resized before │ │ │ │ │ +usage. │ │ │ │ │ +DDeeffiinniittiioonn treecontainer.hh:186 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d_:_:_T_r_e_e_C_o_n_t_a_i_n_e_r_V_e_c_t_o_r_B_a_c_k_e_n_d │ │ │ │ │ +TreeContainerVectorBackend(const Tree &tree) │ │ │ │ │ +Default construct the container and perform a resize depending on the tree-node │ │ │ │ │ +degrees. │ │ │ │ │ +DDeeffiinniittiioonn treecontainer.hh:177 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_L_e_a_f_T_o_D_e_f_a_u_l_t_C_o_n_s_t_r_u_c_t_i_b_l_e_V_a_l_u_e │ │ │ │ │ +DDeeffiinniittiioonn treecontainer.hh:238 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_L_e_a_f_T_o_D_e_f_a_u_l_t_C_o_n_s_t_r_u_c_t_i_b_l_e_V_a_l_u_e_:_:_o_p_e_r_a_t_o_r_(_) │ │ │ │ │ +auto operator()(const Node &node) const │ │ │ │ │ +DDeeffiinniittiioonn treecontainer.hh:240 │ │ │ │ │ +_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 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00020.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: transformation.hh File Reference │ │ │ │ +dune-typetree: transformationutilities.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -69,55 +69,21 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ -
    │ │ │ │ -Classes | │ │ │ │ -Namespaces | │ │ │ │ -Functions
    │ │ │ │ -
    transformation.hh File Reference
    │ │ │ │ +
    transformationutilities.hh File Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │ -
    #include <array>
    │ │ │ │ -#include <tuple>
    │ │ │ │ -#include <memory>
    │ │ │ │ -#include <utility>
    │ │ │ │ -#include <dune/common/hybridutilities.hh>
    │ │ │ │ -#include <dune/common/exceptions.hh>
    │ │ │ │ -#include <dune/common/typetraits.hh>
    │ │ │ │ -#include <dune/typetree/typetraits.hh>
    │ │ │ │ -#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ -#include <dune/typetree/nodetags.hh>
    │ │ │ │ -#include <dune/typetree/utility.hh>
    │ │ │ │ +
    #include <dune/typetree/simpletransformationdescriptors.hh>
    │ │ │ │ +#include <dune/typetree/generictransformationdescriptors.hh>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -

    │ │ │ │ -Classes

    struct  Dune::TypeTree::TransformTree< SourceTree, Transformation, Tag, recursive >
     Transform a TypeTree. More...
     
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -

    │ │ │ │ -Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
     
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -

    │ │ │ │ -Functions

    template<typename SourceNode , typename Transformation , typename Tag >
    void Dune::TypeTree::registerNodeTransformation (SourceNode *, Transformation *, Tag *)
     Register transformation descriptor to transform SourceNode with Transformation.
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,39 +1,12 @@ │ │ │ │ │ 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 │ │ │ │ │ -transformation.hh File Reference │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_y_p_e_t_r_a_i_t_s_._h_h> │ │ │ │ │ -#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_/_u_t_i_l_i_t_y_._h_h> │ │ │ │ │ +transformationutilities.hh File Reference │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_s_i_m_p_l_e_t_r_a_n_s_f_o_r_m_a_t_i_o_n_d_e_s_c_r_i_p_t_o_r_s_._h_h> │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_g_e_n_e_r_i_c_t_r_a_n_s_f_o_r_m_a_t_i_o_n_d_e_s_c_r_i_p_t_o_r_s_._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_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e_<_ _S_o_u_r_c_e_T_r_e_e_,_ _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_a_g_, │ │ │ │ │ - _r_e_c_u_r_s_i_v_e_ _> │ │ │ │ │ -  Transform 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 │ │ │ │ │ -  │ │ │ │ │ -FFuunnccttiioonnss │ │ │ │ │ -template │ │ │ │ │ -void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_r_e_g_i_s_t_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n (SourceNode *, Transformation │ │ │ │ │ - *, Tag *) │ │ │ │ │ -  Register transformation descriptor to transform SourceNode with │ │ │ │ │ - Transformation. │ │ │ │ │ -  │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00020_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: transformation.hh Source File │ │ │ │ +dune-typetree: transformationutilities.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,512 +74,31 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -
    transformation.hh
    │ │ │ │ +
    transformationutilities.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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_TRANSFORMATION_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_TRANSFORMATION_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_TRANSFORMATIONUTILITIES_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_TRANSFORMATIONUTILITIES_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <array>
    │ │ │ │ -
    10#include <tuple>
    │ │ │ │ -
    11#include <memory>
    │ │ │ │ -
    12#include <utility>
    │ │ │ │ -
    13
    │ │ │ │ -
    14#include <dune/common/hybridutilities.hh>
    │ │ │ │ -
    15#include <dune/common/exceptions.hh>
    │ │ │ │ -
    16#include <dune/common/typetraits.hh>
    │ │ │ │ -
    17#include <dune/typetree/typetraits.hh>
    │ │ │ │ -
    18#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ -
    19#include <dune/typetree/nodetags.hh>
    │ │ │ │ -
    20#include <dune/typetree/utility.hh>
    │ │ │ │ -
    21
    │ │ │ │ -
    22
    │ │ │ │ -
    23namespace Dune {
    │ │ │ │ -
    24 namespace TypeTree {
    │ │ │ │ -
    25
    │ │ │ │ -
    31#ifdef DOXYGEN
    │ │ │ │ -
    32
    │ │ │ │ -
    34
    │ │ │ │ -
    53 template<typename SourceNode, typename Transformation, typename Tag>
    │ │ │ │ -
    54 void registerNodeTransformation(SourceNode*, Transformation*, Tag*);
    │ │ │ │ -
    55
    │ │ │ │ -
    56#else // DOXYGEN
    │ │ │ │ -
    57
    │ │ │ │ -
    68 template<typename S, typename T, typename Tag>
    │ │ │ │ -
    69 struct LookupNodeTransformation
    │ │ │ │ -
    70 {
    │ │ │ │ -
    71
    │ │ │ │ -
    72 typedef decltype(registerNodeTransformation(declptr<S>(),declptr<T>(),declptr<Tag>())) lookup_type;
    │ │ │ │ -
    73
    │ │ │ │ -
    74 typedef typename evaluate_if_meta_function<
    │ │ │ │ -
    75 lookup_type
    │ │ │ │ -
    76 >::type type;
    │ │ │ │ -
    77
    │ │ │ │ -
    78 static_assert((!std::is_same<type,void>::value), "Unable to find valid transformation descriptor");
    │ │ │ │ -
    79 };
    │ │ │ │ -
    80
    │ │ │ │ -
    81#endif // DOXYGEN
    │ │ │ │ -
    82
    │ │ │ │ -
    83
    │ │ │ │ -
    85
    │ │ │ │ -
    94 template<typename SourceTree, typename Transformation, typename Tag = StartTag, bool recursive = true>
    │ │ │ │ -
    │ │ │ │ -
    95 struct TransformTree
    │ │ │ │ -
    96 {
    │ │ │ │ -
    97
    │ │ │ │ -
    98#ifndef DOXYGEN
    │ │ │ │ -
    99
    │ │ │ │ -
    100 typedef typename LookupNodeTransformation<SourceTree,Transformation,typename SourceTree::ImplementationTag>::type NodeTransformation;
    │ │ │ │ -
    101
    │ │ │ │ -
    102 // the type of the new tree that will result from this transformation
    │ │ │ │ -
    103 typedef typename TransformTree<SourceTree,Transformation,NodeTag<SourceTree>,NodeTransformation::recursive>::transformed_type transformed_type;
    │ │ │ │ -
    104
    │ │ │ │ -
    105 // the storage type of the new tree that will result from this transformation
    │ │ │ │ -
    106 typedef typename TransformTree<SourceTree,Transformation,NodeTag<SourceTree>,NodeTransformation::recursive>::transformed_storage_type transformed_storage_type;
    │ │ │ │ -
    107
    │ │ │ │ -
    108#endif // DOXYGEN
    │ │ │ │ -
    109
    │ │ │ │ -
    111 typedef transformed_type type;
    │ │ │ │ -
    112
    │ │ │ │ -
    113 typedef type Type;
    │ │ │ │ -
    114
    │ │ │ │ -
    │ │ │ │ -
    116 static transformed_type transform(const SourceTree& s, const Transformation& t = Transformation())
    │ │ │ │ -
    117 {
    │ │ │ │ -
    118 return TransformTree<SourceTree,Transformation,NodeTag<SourceTree>,NodeTransformation::recursive>::transform(s,t);
    │ │ │ │ -
    119 }
    │ │ │ │ -
    │ │ │ │ -
    120
    │ │ │ │ -
    │ │ │ │ -
    122 static transformed_type transform(const SourceTree& s, Transformation& t)
    │ │ │ │ -
    123 {
    │ │ │ │ -
    124 return TransformTree<SourceTree,Transformation,NodeTag<SourceTree>,NodeTransformation::recursive>::transform(s,t);
    │ │ │ │ -
    125 }
    │ │ │ │ -
    │ │ │ │ -
    126
    │ │ │ │ -
    │ │ │ │ -
    128 static transformed_type transform(std::shared_ptr<const SourceTree> sp, const Transformation& t = Transformation())
    │ │ │ │ -
    129 {
    │ │ │ │ -
    130 return TransformTree<SourceTree,Transformation,NodeTag<SourceTree>,NodeTransformation::recursive>::transform(sp,t);
    │ │ │ │ -
    131 }
    │ │ │ │ -
    │ │ │ │ -
    132
    │ │ │ │ -
    │ │ │ │ -
    134 static transformed_type transform(std::shared_ptr<const SourceTree> sp, Transformation& t)
    │ │ │ │ -
    135 {
    │ │ │ │ -
    136 return TransformTree<SourceTree,Transformation,NodeTag<SourceTree>,NodeTransformation::recursive>::transform(sp,t);
    │ │ │ │ -
    137 }
    │ │ │ │ -
    │ │ │ │ -
    138
    │ │ │ │ -
    │ │ │ │ -
    141 static transformed_storage_type transform_storage(std::shared_ptr<const SourceTree> sp, const Transformation& t = Transformation())
    │ │ │ │ -
    142 {
    │ │ │ │ -
    143 return TransformTree<SourceTree,Transformation,NodeTag<SourceTree>,NodeTransformation::recursive>::transform_storage(sp,t);
    │ │ │ │ -
    144 }
    │ │ │ │ -
    │ │ │ │ -
    145
    │ │ │ │ -
    │ │ │ │ -
    148 static transformed_storage_type transform_storage(std::shared_ptr<const SourceTree> sp, Transformation& t)
    │ │ │ │ -
    149 {
    │ │ │ │ -
    150 return TransformTree<SourceTree,Transformation,NodeTag<SourceTree>,NodeTransformation::recursive>::transform_storage(sp,t);
    │ │ │ │ -
    151 }
    │ │ │ │ -
    │ │ │ │ -
    152
    │ │ │ │ -
    153
    │ │ │ │ -
    154 };
    │ │ │ │ -
    │ │ │ │ -
    155
    │ │ │ │ -
    156#ifndef DOXYGEN // internal per-node implementations of the transformation algorithm
    │ │ │ │ -
    157
    │ │ │ │ -
    158 // handle a leaf node - this is easy
    │ │ │ │ -
    159 template<typename S, typename T, bool recursive>
    │ │ │ │ -
    160 struct TransformTree<S,T,LeafNodeTag,recursive>
    │ │ │ │ -
    161 {
    │ │ │ │ -
    162 // get transformed type from specification
    │ │ │ │ -
    163 typedef typename LookupNodeTransformation<S,T,ImplementationTag<S>>::type NodeTransformation;
    │ │ │ │ -
    164
    │ │ │ │ -
    165 typedef typename NodeTransformation::transformed_type transformed_type;
    │ │ │ │ -
    166 typedef typename NodeTransformation::transformed_storage_type transformed_storage_type;
    │ │ │ │ -
    167
    │ │ │ │ -
    168 // delegate instance transformation to per-node specification
    │ │ │ │ -
    169 static transformed_type transform(const S& s, T& t)
    │ │ │ │ -
    170 {
    │ │ │ │ -
    171 return NodeTransformation::transform(s,t);
    │ │ │ │ -
    172 }
    │ │ │ │ -
    173
    │ │ │ │ -
    174 // delegate instance transformation to per-node specification
    │ │ │ │ -
    175 static transformed_type transform(const S& s, const T& t)
    │ │ │ │ -
    176 {
    │ │ │ │ -
    177 return NodeTransformation::transform(s,t);
    │ │ │ │ -
    178 }
    │ │ │ │ -
    179
    │ │ │ │ -
    180 // delegate instance transformation to per-node specification
    │ │ │ │ -
    181 static transformed_type transform(std::shared_ptr<const S> sp, T& t)
    │ │ │ │ -
    182 {
    │ │ │ │ -
    183 return NodeTransformation::transform(sp,t);
    │ │ │ │ -
    184 }
    │ │ │ │ -
    185
    │ │ │ │ -
    186 // delegate instance transformation to per-node specification
    │ │ │ │ -
    187 static transformed_type transform(std::shared_ptr<const S> sp, const T& t)
    │ │ │ │ -
    188 {
    │ │ │ │ -
    189 return NodeTransformation::transform(sp,t);
    │ │ │ │ -
    190 }
    │ │ │ │ -
    191
    │ │ │ │ -
    192 static transformed_storage_type transform_storage(std::shared_ptr<const S> sp, T& t)
    │ │ │ │ -
    193 {
    │ │ │ │ -
    194 return NodeTransformation::transform_storage(sp,t);
    │ │ │ │ -
    195 }
    │ │ │ │ -
    196
    │ │ │ │ -
    197 static transformed_storage_type transform_storage(std::shared_ptr<const S> sp, const T& t)
    │ │ │ │ -
    198 {
    │ │ │ │ -
    199 return NodeTransformation::transform_storage(sp,t);
    │ │ │ │ -
    200 }
    │ │ │ │ -
    201
    │ │ │ │ -
    202 };
    │ │ │ │ -
    203
    │ │ │ │ -
    204
    │ │ │ │ -
    205 // common implementation for non-recursive transformation of non-leaf nodes
    │ │ │ │ -
    206 template<typename S, typename T>
    │ │ │ │ -
    207 struct TransformTreeNonRecursive
    │ │ │ │ -
    208 {
    │ │ │ │ -
    209 // get transformed type from specification
    │ │ │ │ -
    210 typedef typename LookupNodeTransformation<S,T,ImplementationTag<S>>::type NodeTransformation;
    │ │ │ │ -
    211
    │ │ │ │ -
    212 typedef typename NodeTransformation::transformed_type transformed_type;
    │ │ │ │ -
    213 typedef typename NodeTransformation::transformed_storage_type transformed_storage_type;
    │ │ │ │ -
    214
    │ │ │ │ -
    215 // delegate instance transformation to per-node specification
    │ │ │ │ -
    216 static transformed_type transform(const S& s, T& t)
    │ │ │ │ -
    217 {
    │ │ │ │ -
    218 return NodeTransformation::transform(s,t);
    │ │ │ │ -
    219 }
    │ │ │ │ -
    220
    │ │ │ │ -
    221 // delegate instance transformation to per-node specification
    │ │ │ │ -
    222 static transformed_type transform(const S& s, const T& t)
    │ │ │ │ -
    223 {
    │ │ │ │ -
    224 return NodeTransformation::transform(s,t);
    │ │ │ │ -
    225 }
    │ │ │ │ -
    226
    │ │ │ │ -
    227 // delegate instance transformation to per-node specification
    │ │ │ │ -
    228 static transformed_type transform(std::shared_ptr<const S> sp, T& t)
    │ │ │ │ -
    229 {
    │ │ │ │ -
    230 return NodeTransformation::transform(sp,t);
    │ │ │ │ -
    231 }
    │ │ │ │ -
    232
    │ │ │ │ -
    233 // delegate instance transformation to per-node specification
    │ │ │ │ -
    234 static transformed_type transform(std::shared_ptr<const S> sp, const T& t)
    │ │ │ │ -
    235 {
    │ │ │ │ -
    236 return NodeTransformation::transform(sp,t);
    │ │ │ │ -
    237 }
    │ │ │ │ -
    238
    │ │ │ │ -
    239 static transformed_storage_type transform_storage(std::shared_ptr<const S> sp, T& t)
    │ │ │ │ -
    240 {
    │ │ │ │ -
    241 return NodeTransformation::transform_storage(sp,t);
    │ │ │ │ -
    242 }
    │ │ │ │ -
    243
    │ │ │ │ -
    244 static transformed_storage_type transform_storage(std::shared_ptr<const S> sp, const T& t)
    │ │ │ │ -
    245 {
    │ │ │ │ -
    246 return NodeTransformation::transform_storage(sp,t);
    │ │ │ │ -
    247 }
    │ │ │ │ -
    248
    │ │ │ │ -
    249 };
    │ │ │ │ -
    250
    │ │ │ │ -
    251
    │ │ │ │ -
    252 namespace Impl {
    │ │ │ │ -
    253
    │ │ │ │ -
    254 // Helper class to handle recursive power nodes
    │ │ │ │ -
    255 template<class Source, class Transformation, class Tag>
    │ │ │ │ -
    256 class RecursivePowerTransformTree
    │ │ │ │ -
    257 {
    │ │ │ │ -
    258 // We only know two types of tags!
    │ │ │ │ -
    259 static_assert(std::is_same_v<Tag,PowerNodeTag> or std::is_same_v<Tag,DynamicPowerNodeTag>);
    │ │ │ │ -
    260
    │ │ │ │ -
    261 using ChildType = typename Source::ChildType;
    │ │ │ │ -
    262
    │ │ │ │ -
    263 // in case degree is dynamic, provid a vector correctly initialized
    │ │ │ │ -
    264 template<class NodeStorage>
    │ │ │ │ -
    265 static auto node_storage_provider(const std::size_t& degree)
    │ │ │ │ -
    266 {
    │ │ │ │ -
    267 return std::vector<NodeStorage>(degree);
    │ │ │ │ -
    268 }
    │ │ │ │ -
    269
    │ │ │ │ -
    270 // in case degree is static, provid an array
    │ │ │ │ -
    271 template<class NodeStorage, class StaticIndex>
    │ │ │ │ -
    272 static auto node_storage_provider(StaticIndex)
    │ │ │ │ -
    273 {
    │ │ │ │ -
    274 return std::array<NodeStorage,std::size_t(StaticIndex{})>();
    │ │ │ │ -
    275 }
    │ │ │ │ -
    276
    │ │ │ │ -
    277 public:
    │ │ │ │ -
    278 // get transformed type from specification
    │ │ │ │ -
    279 // Handling this transformation in a way that makes the per-node specification easy to write
    │ │ │ │ -
    280 // is a little involved:
    │ │ │ │ -
    281 // The problem is that the transformed power node must be parameterized on the transformed child
    │ │ │ │ -
    282 // type. So we need to transform the child type and pass the transformed child type to an inner
    │ │ │ │ -
    283 // template of the node transformation struct called result (see example of such a specification
    │ │ │ │ -
    284 // further down).
    │ │ │ │ -
    285 using NodeTransformation = typename LookupNodeTransformation<Source,Transformation,ImplementationTag<Source>>::type;
    │ │ │ │ -
    286 using ChildNodeTransformation = typename LookupNodeTransformation<ChildType,Transformation,ImplementationTag<ChildType>>::type;
    │ │ │ │ -
    287
    │ │ │ │ -
    288 private:
    │ │ │ │ -
    289 // Since every child is same type, is enough to get transformation once
    │ │ │ │ -
    290 using ChildTreeTransformation = TransformTree<ChildType,
    │ │ │ │ -
    291 Transformation,
    │ │ │ │ -
    292 NodeTag<ChildType>,
    │ │ │ │ -
    293 ChildNodeTransformation::recursive>;
    │ │ │ │ -
    294
    │ │ │ │ -
    295 // Get transformed type of children
    │ │ │ │ -
    296 using transformed_child_type = typename ChildTreeTransformation::transformed_type;
    │ │ │ │ -
    297 using transformed_child_storage_type = typename ChildTreeTransformation::transformed_storage_type;
    │ │ │ │ -
    298 public:
    │ │ │ │ -
    299 // Apply transformation from children to current node
    │ │ │ │ -
    300 using transformed_type = typename NodeTransformation::template result<transformed_child_type>::type;
    │ │ │ │ -
    301 using transformed_storage_type = typename NodeTransformation::template result<transformed_child_type>::storage_type;
    │ │ │ │ -
    302
    │ │ │ │ -
    303 // Transform an instance of source tree.
    │ │ │ │ -
    304 static transformed_type transform(const Source& source, Transformation& transformation)
    │ │ │ │ -
    305 {
    │ │ │ │ -
    306 auto children_storage = node_storage_provider<std::shared_ptr<transformed_child_type>>(source.degree());
    │ │ │ │ -
    307 for (std::size_t k = 0; k < source.degree(); ++k) {
    │ │ │ │ -
    308 children_storage[k] = ChildTreeTransformation::transform_storage(source.childStorage(k),transformation);
    │ │ │ │ -
    309 }
    │ │ │ │ -
    310 return NodeTransformation::transform(source,transformation,children_storage);
    │ │ │ │ -
    311 }
    │ │ │ │ -
    312
    │ │ │ │ -
    313 // Transform an instance of source tree.
    │ │ │ │ -
    314 static transformed_type transform(const Source& source, const Transformation& transformation)
    │ │ │ │ -
    315 {
    │ │ │ │ -
    316 auto children_storage = node_storage_provider<std::shared_ptr<transformed_child_type>>(source.degree());
    │ │ │ │ -
    317 for (std::size_t k = 0; k < source.degree(); ++k) {
    │ │ │ │ -
    318 children_storage[k] = ChildTreeTransformation::transform_storage(source.childStorage(k),transformation);
    │ │ │ │ -
    319 }
    │ │ │ │ -
    320 return NodeTransformation::transform(source,transformation,children_storage);
    │ │ │ │ -
    321 }
    │ │ │ │ -
    322
    │ │ │ │ -
    323 // Transform an instance of source tree.
    │ │ │ │ -
    324 static transformed_type transform(std::shared_ptr<const Source> source_ptr, Transformation& transformation)
    │ │ │ │ -
    325 {
    │ │ │ │ -
    326 auto children_storage = node_storage_provider<std::shared_ptr<transformed_child_type>>(source_ptr->degree());
    │ │ │ │ -
    327 for (std::size_t k = 0; k < source_ptr->degree(); ++k) {
    │ │ │ │ -
    328 children_storage[k] = ChildTreeTransformation::transform_storage(source_ptr->childStorage(k),transformation);
    │ │ │ │ -
    329 }
    │ │ │ │ -
    330 return NodeTransformation::transform(source_ptr,transformation,children_storage);
    │ │ │ │ -
    331 }
    │ │ │ │ -
    332
    │ │ │ │ -
    333 // Transform an instance of source tree.
    │ │ │ │ -
    334 static transformed_type transform(std::shared_ptr<const Source> source_ptr, const Transformation& transformation)
    │ │ │ │ -
    335 {
    │ │ │ │ -
    336 auto children_storage = node_storage_provider<std::shared_ptr<transformed_child_type>>(source_ptr->degree());
    │ │ │ │ -
    337 for (std::size_t k = 0; k < source_ptr->degree(); ++k) {
    │ │ │ │ -
    338 children_storage[k] = ChildTreeTransformation::transform_storage(source_ptr->childStorage(k),transformation);
    │ │ │ │ -
    339 }
    │ │ │ │ -
    340 return NodeTransformation::transform(source_ptr,transformation,children_storage);
    │ │ │ │ -
    341 }
    │ │ │ │ -
    342
    │ │ │ │ -
    343 // Transform an instance of source tree ptr.
    │ │ │ │ -
    344 static transformed_storage_type transform_storage(std::shared_ptr<const Source> source_ptr, Transformation& transformation)
    │ │ │ │ -
    345 {
    │ │ │ │ -
    346 auto children_storage = node_storage_provider<transformed_child_storage_type>(source_ptr->degree());
    │ │ │ │ -
    347 for (std::size_t k = 0; k < source_ptr->degree(); ++k) {
    │ │ │ │ -
    348 children_storage[k] = ChildTreeTransformation::transform_storage(source_ptr->childStorage(k),transformation);
    │ │ │ │ -
    349 }
    │ │ │ │ -
    350 return NodeTransformation::transform_storage(source_ptr,transformation,children_storage);
    │ │ │ │ -
    351 }
    │ │ │ │ -
    352
    │ │ │ │ -
    353 // Transform an instance of source tree ptr.
    │ │ │ │ -
    354 static transformed_storage_type transform_storage(std::shared_ptr<const Source> source_ptr, const Transformation& transformation)
    │ │ │ │ -
    355 {
    │ │ │ │ -
    356 auto children_storage = node_storage_provider<transformed_child_storage_type>(source_ptr->degree());
    │ │ │ │ -
    357 for (std::size_t k = 0; k < source_ptr->degree(); ++k) {
    │ │ │ │ -
    358 children_storage[k] = ChildTreeTransformation::transform_storage(source_ptr->childStorage(k),transformation);
    │ │ │ │ -
    359 }
    │ │ │ │ -
    360 return NodeTransformation::transform_storage(source_ptr,transformation,children_storage);
    │ │ │ │ -
    361 }
    │ │ │ │ -
    362
    │ │ │ │ -
    363 };
    │ │ │ │ -
    364 } // namespace Impl
    │ │ │ │ -
    365
    │ │ │ │ -
    366 // Recursive version of the PowerNode transformation for static nodes.
    │ │ │ │ -
    367 template<typename Source, typename Transformation>
    │ │ │ │ -
    368 struct TransformTree<Source,Transformation,PowerNodeTag,true>
    │ │ │ │ -
    369 : public Impl::RecursivePowerTransformTree<Source,Transformation,PowerNodeTag>
    │ │ │ │ -
    370 {};
    │ │ │ │ -
    371
    │ │ │ │ -
    372 // Recursive version of the DynamicPowerNode transformation for static nodes.
    │ │ │ │ -
    373 template<typename Source, typename Transformation>
    │ │ │ │ -
    374 struct TransformTree<Source,Transformation,DynamicPowerNodeTag,true>
    │ │ │ │ -
    375 : public Impl::RecursivePowerTransformTree<Source,Transformation,DynamicPowerNodeTag>
    │ │ │ │ -
    376 {};
    │ │ │ │ -
    377
    │ │ │ │ -
    378 // non-recursive version of the PowerNode transformation.
    │ │ │ │ -
    379 template<typename S, typename T>
    │ │ │ │ -
    380 struct TransformTree<S,T,PowerNodeTag,false>
    │ │ │ │ -
    381 : public TransformTreeNonRecursive<S,T>
    │ │ │ │ -
    382 {};
    │ │ │ │ -
    383
    │ │ │ │ -
    384 // non-recursive version of the DynamicPowerNodeTag transformation.
    │ │ │ │ -
    385 template<typename S, typename T>
    │ │ │ │ -
    386 struct TransformTree<S,T,DynamicPowerNodeTag,false>
    │ │ │ │ -
    387 : public TransformTreeNonRecursive<S,T>
    │ │ │ │ -
    388 {};
    │ │ │ │ -
    389
    │ │ │ │ -
    390 // helper struct that does the actual transformation for a composite node. We need this additional struct
    │ │ │ │ -
    391 // to extract the template argument list with the types of all children from the node, which we cannot do
    │ │ │ │ -
    392 // directly in the transformation<> template, as the type passed to transformation<> will usually be a
    │ │ │ │ -
    393 // derived type and will normally have more template arguments than just the children. This declaration
    │ │ │ │ -
    394 // just introduces the type of the helper struct, we always instantiate the specialization defined below;
    │ │ │ │ -
    395 template<typename S, typename Children, typename T>
    │ │ │ │ -
    396 struct transform_composite_node;
    │ │ │ │ -
    397
    │ │ │ │ -
    398 // specialized version of the helper struct which extracts the template argument list with the children from
    │ │ │ │ -
    399 // its second template parameter, which has to be CompositeNode::ChildTypes. Apart from that, the struct is
    │ │ │ │ -
    400 // similar to the one for a PowerNode, but it obviously delegates transformation of the children to the TMP.
    │ │ │ │ -
    401 template<typename S, typename T, typename... C>
    │ │ │ │ -
    402 struct transform_composite_node<S,std::tuple<C...>,T>
    │ │ │ │ -
    403 {
    │ │ │ │ -
    404
    │ │ │ │ -
    405 // transformed type, using the same nested struct trick as the PowerNode
    │ │ │ │ -
    406 typedef ImplementationTag<S> Tag;
    │ │ │ │ -
    407 typedef typename LookupNodeTransformation<S,T,Tag>::type NodeTransformation;
    │ │ │ │ -
    408 typedef typename NodeTransformation::template result<typename TransformTree<C,
    │ │ │ │ -
    409 T,
    │ │ │ │ -
    410 NodeTag<C>,
    │ │ │ │ -
    411 LookupNodeTransformation<C,T,ImplementationTag<C>>::type::recursive
    │ │ │ │ -
    412 >::transformed_type...
    │ │ │ │ -
    413 >::type transformed_type;
    │ │ │ │ -
    414
    │ │ │ │ -
    415 typedef typename NodeTransformation::template result<typename TransformTree<C,
    │ │ │ │ -
    416 T,
    │ │ │ │ -
    417 NodeTag<C>,
    │ │ │ │ -
    418 LookupNodeTransformation<C,T,ImplementationTag<C>>::type::recursive
    │ │ │ │ -
    419 >::transformed_type...
    │ │ │ │ -
    420 >::storage_type transformed_storage_type;
    │ │ │ │ -
    421
    │ │ │ │ -
    422 // Retrieve the transformation descriptor for the child with index i.
    │ │ │ │ -
    423 // This little helper improves really improves the readability of the
    │ │ │ │ -
    424 // transformation functions.
    │ │ │ │ -
    425 template<std::size_t i>
    │ │ │ │ -
    426 struct ChildTransformation
    │ │ │ │ -
    427 : public TransformTree<typename S::template Child<i>::Type,
    │ │ │ │ -
    428 T,
    │ │ │ │ -
    429 NodeTag<typename S::template Child<i>::Type>,
    │ │ │ │ -
    430 LookupNodeTransformation<
    │ │ │ │ -
    431 typename S::template Child<i>::Type,
    │ │ │ │ -
    432 T,
    │ │ │ │ -
    433 ImplementationTag<typename S::template Child<i>::Type>
    │ │ │ │ -
    434 >::type::recursive
    │ │ │ │ -
    435 >
    │ │ │ │ -
    436 {};
    │ │ │ │ -
    437
    │ │ │ │ -
    438 template<std::size_t i, typename Tuple, typename Value>
    │ │ │ │ -
    439 static void setElement(Tuple& tuple, Value&& value)
    │ │ │ │ -
    440 {
    │ │ │ │ -
    441 std::get<i>(tuple) = std::forward<Value>(value);
    │ │ │ │ -
    442 }
    │ │ │ │ -
    443
    │ │ │ │ -
    444 template<typename Trafo, std::size_t... i>
    │ │ │ │ -
    445 static transformed_type transform(const S& s, Trafo&& t, std::index_sequence<i...> indices)
    │ │ │ │ -
    446 {
    │ │ │ │ -
    447 std::tuple<typename ChildTransformation<i>::transformed_storage_type...> storage;
    │ │ │ │ -
    448 Dune::Hybrid::Impl::evaluateFoldExpression<int>({(setElement<i>(storage, ChildTransformation<i>::transform_storage(s.template childStorage<i>(), std::forward<Trafo>(t))),0)...});
    │ │ │ │ -
    449 return NodeTransformation::transform(s, std::forward<Trafo>(t), std::get<i>(storage)...);
    │ │ │ │ -
    450 }
    │ │ │ │ -
    451
    │ │ │ │ -
    452 template<typename Trafo, std::size_t... i>
    │ │ │ │ -
    453 static transformed_storage_type transform_storage(std::shared_ptr<const S> sp, Trafo&& t, std::index_sequence<i...> indices)
    │ │ │ │ -
    454 {
    │ │ │ │ -
    455 std::tuple<typename ChildTransformation<i>::transformed_storage_type...> storage;
    │ │ │ │ -
    456 Dune::Hybrid::Impl::evaluateFoldExpression<int>({(setElement<i>(storage, ChildTransformation<i>::transform_storage(sp->template childStorage<i>(), std::forward<Trafo>(t))),0)...});
    │ │ │ │ -
    457 return NodeTransformation::transform_storage(sp, std::forward<Trafo>(t), std::get<i>(storage)...);
    │ │ │ │ -
    458 }
    │ │ │ │ -
    459 };
    │ │ │ │ -
    460
    │ │ │ │ -
    461
    │ │ │ │ -
    462 // the specialization of transformation<> for the CompositeNode. This just extracts the
    │ │ │ │ -
    463 // CompositeNode::ChildTypes member and forwards to the helper struct
    │ │ │ │ -
    464 template<typename S, typename T>
    │ │ │ │ -
    465 struct TransformTree<S,T,CompositeNodeTag,true>
    │ │ │ │ -
    466 {
    │ │ │ │ -
    467
    │ │ │ │ -
    468 private:
    │ │ │ │ -
    469
    │ │ │ │ -
    470 typedef typename S::ChildTypes ChildTypes;
    │ │ │ │ -
    471
    │ │ │ │ -
    472 static auto child_indices()
    │ │ │ │ -
    473 {
    │ │ │ │ -
    474 return std::make_index_sequence<S::degree()>();
    │ │ │ │ -
    475 }
    │ │ │ │ -
    476
    │ │ │ │ -
    477 public:
    │ │ │ │ -
    478
    │ │ │ │ -
    479 typedef typename transform_composite_node<S,ChildTypes,T>::transformed_type transformed_type;
    │ │ │ │ -
    480 typedef typename transform_composite_node<S,ChildTypes,T>::transformed_storage_type transformed_storage_type;
    │ │ │ │ -
    481
    │ │ │ │ -
    482 static transformed_type transform(const S& s, T& t)
    │ │ │ │ -
    483 {
    │ │ │ │ -
    484 return transform_composite_node<S,ChildTypes,T>::transform(s,t,child_indices());
    │ │ │ │ -
    485 }
    │ │ │ │ -
    486
    │ │ │ │ -
    487 static transformed_type transform(const S& s, const T& t)
    │ │ │ │ -
    488 {
    │ │ │ │ -
    489 return transform_composite_node<S,ChildTypes,T>::transform(s,t,child_indices());
    │ │ │ │ -
    490 }
    │ │ │ │ -
    491
    │ │ │ │ -
    492 static transformed_storage_type transform_storage(std::shared_ptr<const S> sp, T& t)
    │ │ │ │ -
    493 {
    │ │ │ │ -
    494 return transform_composite_node<S,ChildTypes,T>::transform_storage(sp,t,child_indices());
    │ │ │ │ -
    495 }
    │ │ │ │ -
    496
    │ │ │ │ -
    497 static transformed_storage_type transform_storage(std::shared_ptr<const S> sp, const T& t)
    │ │ │ │ -
    498 {
    │ │ │ │ -
    499 return transform_composite_node<S,ChildTypes,T>::transform_storage(sp,t,child_indices());
    │ │ │ │ -
    500 }
    │ │ │ │ -
    501
    │ │ │ │ -
    502 };
    │ │ │ │ -
    503
    │ │ │ │ -
    504 // non-recursive version of the CompositeNode transformation.
    │ │ │ │ -
    505 template<typename S, typename T>
    │ │ │ │ -
    506 struct TransformTree<S,T,CompositeNodeTag,false>
    │ │ │ │ -
    507 : public TransformTreeNonRecursive<S,T>
    │ │ │ │ -
    508 {};
    │ │ │ │ -
    509
    │ │ │ │ -
    510#endif // DOXYGEN
    │ │ │ │ -
    511
    │ │ │ │ -
    513
    │ │ │ │ -
    514 } // namespace TypeTree
    │ │ │ │ -
    515} //namespace Dune
    │ │ │ │ -
    516
    │ │ │ │ -
    517#endif // DUNE_TYPETREE_TRANSFORMATION_HH
    │ │ │ │ - │ │ │ │ -
    result
    static const result_type result
    Definition accumulate_static.hh:113
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::registerNodeTransformation
    void registerNodeTransformation(SourceNode *, Transformation *, Tag *)
    Register transformation descriptor to transform SourceNode with Transformation.
    │ │ │ │ -
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::TransformTree
    Transform a TypeTree.
    Definition transformation.hh:96
    │ │ │ │ -
    Dune::TypeTree::TransformTree::Type
    type Type
    Definition transformation.hh:113
    │ │ │ │ -
    Dune::TypeTree::TransformTree::transform
    static transformed_type transform(std::shared_ptr< const SourceTree > sp, Transformation &t)
    Apply transformation to an existing tree s.
    Definition transformation.hh:134
    │ │ │ │ -
    Dune::TypeTree::TransformTree::transform
    static transformed_type transform(std::shared_ptr< const SourceTree > sp, const Transformation &t=Transformation())
    Apply transformation to an existing tree s.
    Definition transformation.hh:128
    │ │ │ │ -
    Dune::TypeTree::TransformTree::transform
    static transformed_type transform(const SourceTree &s, Transformation &t)
    Apply transformation to an existing tree s.
    Definition transformation.hh:122
    │ │ │ │ -
    Dune::TypeTree::TransformTree::type
    transformed_type type
    The type of the transformed tree.
    Definition transformation.hh:111
    │ │ │ │ -
    Dune::TypeTree::TransformTree::transform
    static transformed_type transform(const SourceTree &s, const Transformation &t=Transformation())
    Apply transformation to an existing tree s.
    Definition transformation.hh:116
    │ │ │ │ -
    Dune::TypeTree::TransformTree::transform_storage
    static transformed_storage_type transform_storage(std::shared_ptr< const SourceTree > sp, const Transformation &t=Transformation())
    Definition transformation.hh:141
    │ │ │ │ -
    Dune::TypeTree::TransformTree::transform_storage
    static transformed_storage_type transform_storage(std::shared_ptr< const SourceTree > sp, Transformation &t)
    Definition transformation.hh:148
    │ │ │ │ -
    Dune::TypeTree::evaluate_if_meta_function
    Meta function that evaluates its argument iff it inherits from meta_function.
    Definition typetraits.hh:142
    │ │ │ │ +
    9#include <dune/typetree/simpletransformationdescriptors.hh>
    │ │ │ │ +
    10#include <dune/typetree/generictransformationdescriptors.hh>
    │ │ │ │ +
    11
    │ │ │ │ +
    12#endif // DUNE_TYPETREE_TRANSFORMATIONUTILITIES_HH
    │ │ │ │ + │ │ │ │ + │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,634 +1,26 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -transformation.hh │ │ │ │ │ +transformationutilities.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_TRANSFORMATION_HH │ │ │ │ │ -7#define DUNE_TYPETREE_TRANSFORMATION_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_TRANSFORMATIONUTILITIES_HH │ │ │ │ │ +7#define DUNE_TYPETREE_TRANSFORMATIONUTILITIES_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include │ │ │ │ │ -10#include │ │ │ │ │ -11#include │ │ │ │ │ -12#include │ │ │ │ │ -13 │ │ │ │ │ -14#include │ │ │ │ │ -15#include │ │ │ │ │ -16#include │ │ │ │ │ -17#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_y_p_e_t_r_a_i_t_s_._h_h> │ │ │ │ │ -18#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> │ │ │ │ │ -19#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ -20#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_u_t_i_l_i_t_y_._h_h> │ │ │ │ │ -21 │ │ │ │ │ -22 │ │ │ │ │ -23namespace _D_u_n_e { │ │ │ │ │ -24 namespace TypeTree { │ │ │ │ │ -25 │ │ │ │ │ -31#ifdef DOXYGEN │ │ │ │ │ -32 │ │ │ │ │ -34 │ │ │ │ │ -53 template │ │ │ │ │ -_5_4 void _r_e_g_i_s_t_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n(SourceNode*, Transformation*, Tag*); │ │ │ │ │ -55 │ │ │ │ │ -56#else // DOXYGEN │ │ │ │ │ -57 │ │ │ │ │ -68 template │ │ │ │ │ -69 struct LookupNodeTransformation │ │ │ │ │ -70 { │ │ │ │ │ -71 │ │ │ │ │ -72 typedef decltype(_r_e_g_i_s_t_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n(declptr(),declptr │ │ │ │ │ -(),declptr())) lookup_type; │ │ │ │ │ -73 │ │ │ │ │ -74 typedef typename _e_v_a_l_u_a_t_e___i_f___m_e_t_a___f_u_n_c_t_i_o_n< │ │ │ │ │ -75 lookup_type │ │ │ │ │ -76 >::type type; │ │ │ │ │ -77 │ │ │ │ │ -78 static_assert((!std::is_same::value), "Unable to find valid │ │ │ │ │ -transformation descriptor"); │ │ │ │ │ -79 }; │ │ │ │ │ -80 │ │ │ │ │ -81#endif // DOXYGEN │ │ │ │ │ -82 │ │ │ │ │ -83 │ │ │ │ │ -85 │ │ │ │ │ -94 template │ │ │ │ │ -_9_5 struct _T_r_a_n_s_f_o_r_m_T_r_e_e │ │ │ │ │ -96 { │ │ │ │ │ -97 │ │ │ │ │ -98#ifndef DOXYGEN │ │ │ │ │ -99 │ │ │ │ │ -100 typedef typename │ │ │ │ │ -LookupNodeTransformation::type NodeTransformation; │ │ │ │ │ -101 │ │ │ │ │ -102 // the type of the new tree that will result from this transformation │ │ │ │ │ -103 typedef typename │ │ │ │ │ -_T_r_a_n_s_f_o_r_m_T_r_e_e_<_S_o_u_r_c_e_T_r_e_e_,_T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_N_o_d_e_T_a_g_<_S_o_u_r_c_e_T_r_e_e_>,NodeTransformation:: │ │ │ │ │ -recursive>::transformed_type transformed_type; │ │ │ │ │ -104 │ │ │ │ │ -105 // the storage type of the new tree that will result from this │ │ │ │ │ -transformation │ │ │ │ │ -106 typedef typename │ │ │ │ │ -_T_r_a_n_s_f_o_r_m_T_r_e_e_<_S_o_u_r_c_e_T_r_e_e_,_T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_N_o_d_e_T_a_g_<_S_o_u_r_c_e_T_r_e_e_>,NodeTransformation:: │ │ │ │ │ -recursive>::transformed_storage_type transformed_storage_type; │ │ │ │ │ -107 │ │ │ │ │ -108#endif // DOXYGEN │ │ │ │ │ -109 │ │ │ │ │ -_1_1_1 typedef transformed_type _t_y_p_e; │ │ │ │ │ -112 │ │ │ │ │ -_1_1_3 typedef _t_y_p_e _T_y_p_e; │ │ │ │ │ -114 │ │ │ │ │ -_1_1_6 static transformed_type _t_r_a_n_s_f_o_r_m(const SourceTree& s, const │ │ │ │ │ -Transformation& t = Transformation()) │ │ │ │ │ -117 { │ │ │ │ │ -118 return │ │ │ │ │ -_T_r_a_n_s_f_o_r_m_T_r_e_e_<_S_o_u_r_c_e_T_r_e_e_,_T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_N_o_d_e_T_a_g_<_S_o_u_r_c_e_T_r_e_e_>,NodeTransformation:: │ │ │ │ │ -recursive>_:_:_t_r_a_n_s_f_o_r_m(s,t); │ │ │ │ │ -119 } │ │ │ │ │ -120 │ │ │ │ │ -_1_2_2 static transformed_type _t_r_a_n_s_f_o_r_m(const SourceTree& s, Transformation& t) │ │ │ │ │ -123 { │ │ │ │ │ -124 return │ │ │ │ │ -_T_r_a_n_s_f_o_r_m_T_r_e_e_<_S_o_u_r_c_e_T_r_e_e_,_T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_N_o_d_e_T_a_g_<_S_o_u_r_c_e_T_r_e_e_>,NodeTransformation:: │ │ │ │ │ -recursive>_:_:_t_r_a_n_s_f_o_r_m(s,t); │ │ │ │ │ -125 } │ │ │ │ │ -126 │ │ │ │ │ -_1_2_8 static transformed_type _t_r_a_n_s_f_o_r_m(std::shared_ptr sp, │ │ │ │ │ -const Transformation& t = Transformation()) │ │ │ │ │ -129 { │ │ │ │ │ -130 return │ │ │ │ │ -_T_r_a_n_s_f_o_r_m_T_r_e_e_<_S_o_u_r_c_e_T_r_e_e_,_T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_N_o_d_e_T_a_g_<_S_o_u_r_c_e_T_r_e_e_>,NodeTransformation:: │ │ │ │ │ -recursive>_:_:_t_r_a_n_s_f_o_r_m(sp,t); │ │ │ │ │ -131 } │ │ │ │ │ -132 │ │ │ │ │ -_1_3_4 static transformed_type _t_r_a_n_s_f_o_r_m(std::shared_ptr sp, │ │ │ │ │ -Transformation& t) │ │ │ │ │ -135 { │ │ │ │ │ -136 return │ │ │ │ │ -_T_r_a_n_s_f_o_r_m_T_r_e_e_<_S_o_u_r_c_e_T_r_e_e_,_T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_N_o_d_e_T_a_g_<_S_o_u_r_c_e_T_r_e_e_>,NodeTransformation:: │ │ │ │ │ -recursive>_:_:_t_r_a_n_s_f_o_r_m(sp,t); │ │ │ │ │ -137 } │ │ │ │ │ -138 │ │ │ │ │ -_1_4_1 static transformed_storage_type _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std::shared_ptr sp, const Transformation& t = Transformation()) │ │ │ │ │ -142 { │ │ │ │ │ -143 return │ │ │ │ │ -_T_r_a_n_s_f_o_r_m_T_r_e_e_<_S_o_u_r_c_e_T_r_e_e_,_T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_N_o_d_e_T_a_g_<_S_o_u_r_c_e_T_r_e_e_>,NodeTransformation:: │ │ │ │ │ -recursive>_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(sp,t); │ │ │ │ │ -144 } │ │ │ │ │ -145 │ │ │ │ │ -_1_4_8 static transformed_storage_type _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std::shared_ptr sp, Transformation& t) │ │ │ │ │ -149 { │ │ │ │ │ -150 return │ │ │ │ │ -_T_r_a_n_s_f_o_r_m_T_r_e_e_<_S_o_u_r_c_e_T_r_e_e_,_T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_N_o_d_e_T_a_g_<_S_o_u_r_c_e_T_r_e_e_>,NodeTransformation:: │ │ │ │ │ -recursive>_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(sp,t); │ │ │ │ │ -151 } │ │ │ │ │ -152 │ │ │ │ │ -153 │ │ │ │ │ -154 }; │ │ │ │ │ -155 │ │ │ │ │ -156#ifndef DOXYGEN // internal per-node implementations of the transformation │ │ │ │ │ -algorithm │ │ │ │ │ -157 │ │ │ │ │ -158 // handle a leaf node - this is easy │ │ │ │ │ -159 template │ │ │ │ │ -160 struct TransformTree │ │ │ │ │ -161 { │ │ │ │ │ -162 // get transformed type from specification │ │ │ │ │ -163 typedef typename LookupNodeTransformation>_:_:_t_y_p_e │ │ │ │ │ -NodeTransformation; │ │ │ │ │ -164 │ │ │ │ │ -165 typedef typename NodeTransformation::transformed_type transformed_type; │ │ │ │ │ -166 typedef typename NodeTransformation::transformed_storage_type │ │ │ │ │ -transformed_storage_type; │ │ │ │ │ -167 │ │ │ │ │ -168 // delegate instance transformation to per-node specification │ │ │ │ │ -169 static transformed_type _t_r_a_n_s_f_o_r_m(const S& s, T& t) │ │ │ │ │ -170 { │ │ │ │ │ -171 return NodeTransformation::transform(s,t); │ │ │ │ │ -172 } │ │ │ │ │ -173 │ │ │ │ │ -174 // delegate instance transformation to per-node specification │ │ │ │ │ -175 static transformed_type _t_r_a_n_s_f_o_r_m(const S& s, const T& t) │ │ │ │ │ -176 { │ │ │ │ │ -177 return NodeTransformation::transform(s,t); │ │ │ │ │ -178 } │ │ │ │ │ -179 │ │ │ │ │ -180 // delegate instance transformation to per-node specification │ │ │ │ │ -181 static transformed_type _t_r_a_n_s_f_o_r_m(std::shared_ptr sp, T& t) │ │ │ │ │ -182 { │ │ │ │ │ -183 return NodeTransformation::transform(sp,t); │ │ │ │ │ -184 } │ │ │ │ │ -185 │ │ │ │ │ -186 // delegate instance transformation to per-node specification │ │ │ │ │ -187 static transformed_type _t_r_a_n_s_f_o_r_m(std::shared_ptr sp, const T& t) │ │ │ │ │ -188 { │ │ │ │ │ -189 return NodeTransformation::transform(sp,t); │ │ │ │ │ -190 } │ │ │ │ │ -191 │ │ │ │ │ -192 static transformed_storage_type _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std::shared_ptr │ │ │ │ │ -sp, T& t) │ │ │ │ │ -193 { │ │ │ │ │ -194 return NodeTransformation::transform_storage(sp,t); │ │ │ │ │ -195 } │ │ │ │ │ -196 │ │ │ │ │ -197 static transformed_storage_type _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std::shared_ptr │ │ │ │ │ -sp, const T& t) │ │ │ │ │ -198 { │ │ │ │ │ -199 return NodeTransformation::transform_storage(sp,t); │ │ │ │ │ -200 } │ │ │ │ │ -201 │ │ │ │ │ -202 }; │ │ │ │ │ -203 │ │ │ │ │ -204 │ │ │ │ │ -205 // common implementation for non-recursive transformation of non-leaf nodes │ │ │ │ │ -206 template │ │ │ │ │ -207 struct TransformTreeNonRecursive │ │ │ │ │ -208 { │ │ │ │ │ -209 // get transformed type from specification │ │ │ │ │ -210 typedef typename LookupNodeTransformation>::type │ │ │ │ │ -NodeTransformation; │ │ │ │ │ -211 │ │ │ │ │ -212 typedef typename NodeTransformation::transformed_type transformed_type; │ │ │ │ │ -213 typedef typename NodeTransformation::transformed_storage_type │ │ │ │ │ -transformed_storage_type; │ │ │ │ │ -214 │ │ │ │ │ -215 // delegate instance transformation to per-node specification │ │ │ │ │ -216 static transformed_type transform(const S& s, T& t) │ │ │ │ │ -217 { │ │ │ │ │ -218 return NodeTransformation::transform(s,t); │ │ │ │ │ -219 } │ │ │ │ │ -220 │ │ │ │ │ -221 // delegate instance transformation to per-node specification │ │ │ │ │ -222 static transformed_type transform(const S& s, const T& t) │ │ │ │ │ -223 { │ │ │ │ │ -224 return NodeTransformation::transform(s,t); │ │ │ │ │ -225 } │ │ │ │ │ -226 │ │ │ │ │ -227 // delegate instance transformation to per-node specification │ │ │ │ │ -228 static transformed_type transform(std::shared_ptr sp, T& t) │ │ │ │ │ -229 { │ │ │ │ │ -230 return NodeTransformation::transform(sp,t); │ │ │ │ │ -231 } │ │ │ │ │ -232 │ │ │ │ │ -233 // delegate instance transformation to per-node specification │ │ │ │ │ -234 static transformed_type transform(std::shared_ptr sp, const T& t) │ │ │ │ │ -235 { │ │ │ │ │ -236 return NodeTransformation::transform(sp,t); │ │ │ │ │ -237 } │ │ │ │ │ -238 │ │ │ │ │ -239 static transformed_storage_type transform_storage(std::shared_ptr │ │ │ │ │ -sp, T& t) │ │ │ │ │ -240 { │ │ │ │ │ -241 return NodeTransformation::transform_storage(sp,t); │ │ │ │ │ -242 } │ │ │ │ │ -243 │ │ │ │ │ -244 static transformed_storage_type transform_storage(std::shared_ptr │ │ │ │ │ -sp, const T& t) │ │ │ │ │ -245 { │ │ │ │ │ -246 return NodeTransformation::transform_storage(sp,t); │ │ │ │ │ -247 } │ │ │ │ │ -248 │ │ │ │ │ -249 }; │ │ │ │ │ -250 │ │ │ │ │ -251 │ │ │ │ │ -252 namespace Impl { │ │ │ │ │ -253 │ │ │ │ │ -254 // Helper class to handle recursive power nodes │ │ │ │ │ -255 template │ │ │ │ │ -256 class RecursivePowerTransformTree │ │ │ │ │ -257 { │ │ │ │ │ -258 // We only know two types of tags! │ │ │ │ │ -259 static_assert(std::is_same_v or std:: │ │ │ │ │ -is_same_v); │ │ │ │ │ -260 │ │ │ │ │ -261 using ChildType = typename Source::ChildType; │ │ │ │ │ -262 │ │ │ │ │ -263 // in case degree is dynamic, provid a vector correctly initialized │ │ │ │ │ -264 template │ │ │ │ │ -265 static auto node_storage_provider(const std::size_t& degree) │ │ │ │ │ -266 { │ │ │ │ │ -267 return std::vector(degree); │ │ │ │ │ -268 } │ │ │ │ │ -269 │ │ │ │ │ -270 // in case degree is static, provid an array │ │ │ │ │ -271 template │ │ │ │ │ -272 static auto node_storage_provider(StaticIndex) │ │ │ │ │ -273 { │ │ │ │ │ -274 return std::array(); │ │ │ │ │ -275 } │ │ │ │ │ -276 │ │ │ │ │ -277 public: │ │ │ │ │ -278 // get transformed type from specification │ │ │ │ │ -279 // Handling this transformation in a way that makes the per-node │ │ │ │ │ -specification easy to write │ │ │ │ │ -280 // is a little involved: │ │ │ │ │ -281 // The problem is that the transformed power node must be parameterized on │ │ │ │ │ -the transformed child │ │ │ │ │ -282 // type. So we need to transform the child type and pass the transformed │ │ │ │ │ -child type to an inner │ │ │ │ │ -283 // template of the node transformation struct called result (see example of │ │ │ │ │ -such a specification │ │ │ │ │ -284 // further down). │ │ │ │ │ -285 using NodeTransformation = typename │ │ │ │ │ -LookupNodeTransformation>:: │ │ │ │ │ -type; │ │ │ │ │ -286 using ChildNodeTransformation = typename │ │ │ │ │ -LookupNodeTransformation>:: │ │ │ │ │ -type; │ │ │ │ │ -287 │ │ │ │ │ -288 private: │ │ │ │ │ -289 // Since every child is same type, is enough to get transformation once │ │ │ │ │ -290 using ChildTreeTransformation = TransformTree, │ │ │ │ │ -293 ChildNodeTransformation::recursive>; │ │ │ │ │ -294 │ │ │ │ │ -295 // Get transformed type of children │ │ │ │ │ -296 using transformed_child_type = typename ChildTreeTransformation:: │ │ │ │ │ -transformed_type; │ │ │ │ │ -297 using transformed_child_storage_type = typename ChildTreeTransformation:: │ │ │ │ │ -transformed_storage_type; │ │ │ │ │ -298 public: │ │ │ │ │ -299 // Apply transformation from children to current node │ │ │ │ │ -300 using transformed_type = typename NodeTransformation::template │ │ │ │ │ -result::type; │ │ │ │ │ -301 using transformed_storage_type = typename NodeTransformation::template │ │ │ │ │ -result::storage_type; │ │ │ │ │ -302 │ │ │ │ │ -303 // Transform an instance of source tree. │ │ │ │ │ -304 static transformed_type transform(const Source& source, Transformation& │ │ │ │ │ -transformation) │ │ │ │ │ -305 { │ │ │ │ │ -306 auto children_storage = node_storage_provider>(source.degree()); │ │ │ │ │ -307 for (std::size_t k = 0; k < source.degree(); ++k) { │ │ │ │ │ -308 children_storage[k] = ChildTreeTransformation::transform_storage │ │ │ │ │ -(source.childStorage(k),transformation); │ │ │ │ │ -309 } │ │ │ │ │ -310 return NodeTransformation::transform │ │ │ │ │ -(source,transformation,children_storage); │ │ │ │ │ -311 } │ │ │ │ │ -312 │ │ │ │ │ -313 // Transform an instance of source tree. │ │ │ │ │ -314 static transformed_type transform(const Source& source, const │ │ │ │ │ -Transformation& transformation) │ │ │ │ │ -315 { │ │ │ │ │ -316 auto children_storage = node_storage_provider>(source.degree()); │ │ │ │ │ -317 for (std::size_t k = 0; k < source.degree(); ++k) { │ │ │ │ │ -318 children_storage[k] = ChildTreeTransformation::transform_storage │ │ │ │ │ -(source.childStorage(k),transformation); │ │ │ │ │ -319 } │ │ │ │ │ -320 return NodeTransformation::transform │ │ │ │ │ -(source,transformation,children_storage); │ │ │ │ │ -321 } │ │ │ │ │ -322 │ │ │ │ │ -323 // Transform an instance of source tree. │ │ │ │ │ -324 static transformed_type transform(std::shared_ptr source_ptr, │ │ │ │ │ -Transformation& transformation) │ │ │ │ │ -325 { │ │ │ │ │ -326 auto children_storage = node_storage_provider>(source_ptr->degree()); │ │ │ │ │ -327 for (std::size_t k = 0; k < source_ptr->degree(); ++k) { │ │ │ │ │ -328 children_storage[k] = ChildTreeTransformation::transform_storage │ │ │ │ │ -(source_ptr->childStorage(k),transformation); │ │ │ │ │ -329 } │ │ │ │ │ -330 return NodeTransformation::transform │ │ │ │ │ -(source_ptr,transformation,children_storage); │ │ │ │ │ -331 } │ │ │ │ │ -332 │ │ │ │ │ -333 // Transform an instance of source tree. │ │ │ │ │ -334 static transformed_type transform(std::shared_ptr source_ptr, │ │ │ │ │ -const Transformation& transformation) │ │ │ │ │ -335 { │ │ │ │ │ -336 auto children_storage = node_storage_provider>(source_ptr->degree()); │ │ │ │ │ -337 for (std::size_t k = 0; k < source_ptr->degree(); ++k) { │ │ │ │ │ -338 children_storage[k] = ChildTreeTransformation::transform_storage │ │ │ │ │ -(source_ptr->childStorage(k),transformation); │ │ │ │ │ -339 } │ │ │ │ │ -340 return NodeTransformation::transform │ │ │ │ │ -(source_ptr,transformation,children_storage); │ │ │ │ │ -341 } │ │ │ │ │ -342 │ │ │ │ │ -343 // Transform an instance of source tree ptr. │ │ │ │ │ -344 static transformed_storage_type transform_storage(std::shared_ptr source_ptr, Transformation& transformation) │ │ │ │ │ -345 { │ │ │ │ │ -346 auto children_storage = │ │ │ │ │ -node_storage_provider(source_ptr->degree()); │ │ │ │ │ -347 for (std::size_t k = 0; k < source_ptr->degree(); ++k) { │ │ │ │ │ -348 children_storage[k] = ChildTreeTransformation::transform_storage │ │ │ │ │ -(source_ptr->childStorage(k),transformation); │ │ │ │ │ -349 } │ │ │ │ │ -350 return NodeTransformation::transform_storage │ │ │ │ │ -(source_ptr,transformation,children_storage); │ │ │ │ │ -351 } │ │ │ │ │ -352 │ │ │ │ │ -353 // Transform an instance of source tree ptr. │ │ │ │ │ -354 static transformed_storage_type transform_storage(std::shared_ptr source_ptr, const Transformation& transformation) │ │ │ │ │ -355 { │ │ │ │ │ -356 auto children_storage = │ │ │ │ │ -node_storage_provider(source_ptr->degree()); │ │ │ │ │ -357 for (std::size_t k = 0; k < source_ptr->degree(); ++k) { │ │ │ │ │ -358 children_storage[k] = ChildTreeTransformation::transform_storage │ │ │ │ │ -(source_ptr->childStorage(k),transformation); │ │ │ │ │ -359 } │ │ │ │ │ -360 return NodeTransformation::transform_storage │ │ │ │ │ -(source_ptr,transformation,children_storage); │ │ │ │ │ -361 } │ │ │ │ │ -362 │ │ │ │ │ -363 }; │ │ │ │ │ -364 } // namespace Impl │ │ │ │ │ -365 │ │ │ │ │ -366 // Recursive version of the PowerNode transformation for static nodes. │ │ │ │ │ -367 template │ │ │ │ │ -368 struct TransformTree │ │ │ │ │ -369 : public Impl:: │ │ │ │ │ -RecursivePowerTransformTree │ │ │ │ │ -370 {}; │ │ │ │ │ -371 │ │ │ │ │ -372 // Recursive version of the DynamicPowerNode transformation for static │ │ │ │ │ -nodes. │ │ │ │ │ -373 template │ │ │ │ │ -374 struct TransformTree │ │ │ │ │ -375 : public Impl:: │ │ │ │ │ -RecursivePowerTransformTree │ │ │ │ │ -376 {}; │ │ │ │ │ -377 │ │ │ │ │ -378 // non-recursive version of the PowerNode transformation. │ │ │ │ │ -379 template │ │ │ │ │ -380 struct TransformTree │ │ │ │ │ -381 : public TransformTreeNonRecursive │ │ │ │ │ -382 {}; │ │ │ │ │ -383 │ │ │ │ │ -384 // non-recursive version of the DynamicPowerNodeTag transformation. │ │ │ │ │ -385 template │ │ │ │ │ -386 struct TransformTree │ │ │ │ │ -387 : public TransformTreeNonRecursive │ │ │ │ │ -388 {}; │ │ │ │ │ -389 │ │ │ │ │ -390 // helper struct that does the actual transformation for a composite node. │ │ │ │ │ -We need this additional struct │ │ │ │ │ -391 // to extract the template argument list with the types of all children │ │ │ │ │ -from the node, which we cannot do │ │ │ │ │ -392 // directly in the transformation<> template, as the type passed to │ │ │ │ │ -transformation<> will usually be a │ │ │ │ │ -393 // derived type and will normally have more template arguments than just │ │ │ │ │ -the children. This declaration │ │ │ │ │ -394 // just introduces the type of the helper struct, we always instantiate the │ │ │ │ │ -specialization defined below; │ │ │ │ │ -395 template │ │ │ │ │ -396 struct transform_composite_node; │ │ │ │ │ -397 │ │ │ │ │ -398 // specialized version of the helper struct which extracts the template │ │ │ │ │ -argument list with the children from │ │ │ │ │ -399 // its second template parameter, which has to be CompositeNode:: │ │ │ │ │ -ChildTypes. Apart from that, the struct is │ │ │ │ │ -400 // similar to the one for a PowerNode, but it obviously delegates │ │ │ │ │ -transformation of the children to the TMP. │ │ │ │ │ -401 template │ │ │ │ │ -402 struct transform_composite_node,T> │ │ │ │ │ -403 { │ │ │ │ │ -404 │ │ │ │ │ -405 // transformed type, using the same nested struct trick as the PowerNode │ │ │ │ │ -406 typedef ImplementationTag Tag; │ │ │ │ │ -407 typedef typename LookupNodeTransformation::type │ │ │ │ │ -NodeTransformation; │ │ │ │ │ -408 typedef typename NodeTransformation::template _r_e_s_u_l_t, │ │ │ │ │ -411 LookupNodeTransformation>::type::recursive │ │ │ │ │ -412 >::transformed_type... │ │ │ │ │ -413 >::type transformed_type; │ │ │ │ │ -414 │ │ │ │ │ -415 typedef typename NodeTransformation::template _r_e_s_u_l_t, │ │ │ │ │ -418 LookupNodeTransformation>::type::recursive │ │ │ │ │ -419 >::transformed_type... │ │ │ │ │ -420 >::storage_type transformed_storage_type; │ │ │ │ │ -421 │ │ │ │ │ -422 // Retrieve the transformation descriptor for the child with index i. │ │ │ │ │ -423 // This little helper improves really improves the readability of the │ │ │ │ │ -424 // transformation functions. │ │ │ │ │ -425 template │ │ │ │ │ -426 struct ChildTransformation │ │ │ │ │ -427 : public TransformTree::Type, │ │ │ │ │ -428 T, │ │ │ │ │ -429 NodeTag::Type>, │ │ │ │ │ -430 LookupNodeTransformation< │ │ │ │ │ -431 typename S::template Child::Type, │ │ │ │ │ -432 T, │ │ │ │ │ -433 ImplementationTag::Type> │ │ │ │ │ -434 >::type::recursive │ │ │ │ │ -435 > │ │ │ │ │ -436 {}; │ │ │ │ │ -437 │ │ │ │ │ -438 template │ │ │ │ │ -439 static void setElement(Tuple& tuple, Value&& value) │ │ │ │ │ -440 { │ │ │ │ │ -441 std::get(tuple) = std::forward(value); │ │ │ │ │ -442 } │ │ │ │ │ -443 │ │ │ │ │ -444 template │ │ │ │ │ -445 static transformed_type transform(const S& s, Trafo&& t, std:: │ │ │ │ │ -index_sequence indices) │ │ │ │ │ -446 { │ │ │ │ │ -447 std::tuple::transformed_storage_type...> │ │ │ │ │ -storage; │ │ │ │ │ -448 Dune::Hybrid::Impl::evaluateFoldExpression({(setElement(storage, │ │ │ │ │ -ChildTransformation::transform_storage(s.template childStorage(), std:: │ │ │ │ │ -forward(t))),0)...}); │ │ │ │ │ -449 return NodeTransformation::transform(s, std::forward(t), std::get │ │ │ │ │ -(storage)...); │ │ │ │ │ -450 } │ │ │ │ │ -451 │ │ │ │ │ -452 template │ │ │ │ │ -453 static transformed_storage_type transform_storage(std::shared_ptr │ │ │ │ │ -sp, Trafo&& t, std::index_sequence indices) │ │ │ │ │ -454 { │ │ │ │ │ -455 std::tuple::transformed_storage_type...> │ │ │ │ │ -storage; │ │ │ │ │ -456 Dune::Hybrid::Impl::evaluateFoldExpression({(setElement(storage, │ │ │ │ │ -ChildTransformation::transform_storage(sp->template childStorage(), std:: │ │ │ │ │ -forward(t))),0)...}); │ │ │ │ │ -457 return NodeTransformation::transform_storage(sp, std::forward(t), │ │ │ │ │ -std::get(storage)...); │ │ │ │ │ -458 } │ │ │ │ │ -459 }; │ │ │ │ │ -460 │ │ │ │ │ -461 │ │ │ │ │ -462 // the specialization of transformation<> for the CompositeNode. This just │ │ │ │ │ -extracts the │ │ │ │ │ -463 // CompositeNode::ChildTypes member and forwards to the helper struct │ │ │ │ │ -464 template │ │ │ │ │ -465 struct TransformTree │ │ │ │ │ -466 { │ │ │ │ │ -467 │ │ │ │ │ -468 private: │ │ │ │ │ -469 │ │ │ │ │ -470 typedef typename S::ChildTypes ChildTypes; │ │ │ │ │ -471 │ │ │ │ │ -472 static auto child_indices() │ │ │ │ │ -473 { │ │ │ │ │ -474 return std::make_index_sequence(); │ │ │ │ │ -475 } │ │ │ │ │ -476 │ │ │ │ │ -477 public: │ │ │ │ │ -478 │ │ │ │ │ -479 typedef typename transform_composite_node::transformed_type │ │ │ │ │ -transformed_type; │ │ │ │ │ -480 typedef typename transform_composite_node:: │ │ │ │ │ -transformed_storage_type transformed_storage_type; │ │ │ │ │ -481 │ │ │ │ │ -482 static transformed_type _t_r_a_n_s_f_o_r_m(const S& s, T& t) │ │ │ │ │ -483 { │ │ │ │ │ -484 return transform_composite_node::transform │ │ │ │ │ -(s,t,child_indices()); │ │ │ │ │ -485 } │ │ │ │ │ -486 │ │ │ │ │ -487 static transformed_type _t_r_a_n_s_f_o_r_m(const S& s, const T& t) │ │ │ │ │ -488 { │ │ │ │ │ -489 return transform_composite_node::transform │ │ │ │ │ -(s,t,child_indices()); │ │ │ │ │ -490 } │ │ │ │ │ -491 │ │ │ │ │ -492 static transformed_storage_type _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std::shared_ptr │ │ │ │ │ -sp, T& t) │ │ │ │ │ -493 { │ │ │ │ │ -494 return transform_composite_node::transform_storage │ │ │ │ │ -(sp,t,child_indices()); │ │ │ │ │ -495 } │ │ │ │ │ -496 │ │ │ │ │ -497 static transformed_storage_type _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std::shared_ptr │ │ │ │ │ -sp, const T& t) │ │ │ │ │ -498 { │ │ │ │ │ -499 return transform_composite_node::transform_storage │ │ │ │ │ -(sp,t,child_indices()); │ │ │ │ │ -500 } │ │ │ │ │ -501 │ │ │ │ │ -502 }; │ │ │ │ │ -503 │ │ │ │ │ -504 // non-recursive version of the CompositeNode transformation. │ │ │ │ │ -505 template │ │ │ │ │ -506 struct TransformTree │ │ │ │ │ -507 : public TransformTreeNonRecursive │ │ │ │ │ -508 {}; │ │ │ │ │ -509 │ │ │ │ │ -510#endif // DOXYGEN │ │ │ │ │ -511 │ │ │ │ │ -513 │ │ │ │ │ -514 } // namespace TypeTree │ │ │ │ │ -515} //namespace Dune │ │ │ │ │ -516 │ │ │ │ │ -517#endif // DUNE_TYPETREE_TRANSFORMATION_HH │ │ │ │ │ -_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h │ │ │ │ │ -_r_e_s_u_l_t │ │ │ │ │ -static const result_type result │ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:113 │ │ │ │ │ -_t_y_p_e_t_r_a_i_t_s_._h_h │ │ │ │ │ -_u_t_i_l_i_t_y_._h_h │ │ │ │ │ -_n_o_d_e_t_a_g_s_._h_h │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_r_e_g_i_s_t_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -void registerNodeTransformation(SourceNode *, Transformation *, Tag *) │ │ │ │ │ -Register transformation descriptor to transform SourceNode with Transformation. │ │ │ │ │ -_D_u_n_e │ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e │ │ │ │ │ -Transform a TypeTree. │ │ │ │ │ -DDeeffiinniittiioonn transformation.hh:96 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e_:_:_T_y_p_e │ │ │ │ │ -type Type │ │ │ │ │ -DDeeffiinniittiioonn transformation.hh:113 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ -static transformed_type transform(std::shared_ptr< const SourceTree > sp, │ │ │ │ │ -Transformation &t) │ │ │ │ │ -Apply transformation to an existing tree s. │ │ │ │ │ -DDeeffiinniittiioonn transformation.hh:134 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ -static transformed_type transform(std::shared_ptr< const SourceTree > sp, const │ │ │ │ │ -Transformation &t=Transformation()) │ │ │ │ │ -Apply transformation to an existing tree s. │ │ │ │ │ -DDeeffiinniittiioonn transformation.hh:128 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ -static transformed_type transform(const SourceTree &s, Transformation &t) │ │ │ │ │ -Apply transformation to an existing tree s. │ │ │ │ │ -DDeeffiinniittiioonn transformation.hh:122 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e_:_:_t_y_p_e │ │ │ │ │ -transformed_type type │ │ │ │ │ -The type of the transformed tree. │ │ │ │ │ -DDeeffiinniittiioonn transformation.hh:111 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ -static transformed_type transform(const SourceTree &s, const Transformation │ │ │ │ │ -&t=Transformation()) │ │ │ │ │ -Apply transformation to an existing tree s. │ │ │ │ │ -DDeeffiinniittiioonn transformation.hh:116 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ -static transformed_storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ -SourceTree > sp, const Transformation &t=Transformation()) │ │ │ │ │ -DDeeffiinniittiioonn transformation.hh:141 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ -static transformed_storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ -SourceTree > sp, Transformation &t) │ │ │ │ │ -DDeeffiinniittiioonn transformation.hh:148 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_e_v_a_l_u_a_t_e___i_f___m_e_t_a___f_u_n_c_t_i_o_n │ │ │ │ │ -Meta function that evaluates its argument iff it inherits from meta_function. │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:142 │ │ │ │ │ +9#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_s_i_m_p_l_e_t_r_a_n_s_f_o_r_m_a_t_i_o_n_d_e_s_c_r_i_p_t_o_r_s_._h_h> │ │ │ │ │ +10#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_g_e_n_e_r_i_c_t_r_a_n_s_f_o_r_m_a_t_i_o_n_d_e_s_c_r_i_p_t_o_r_s_._h_h> │ │ │ │ │ +11 │ │ │ │ │ +12#endif // DUNE_TYPETREE_TRANSFORMATIONUTILITIES_HH │ │ │ │ │ +_s_i_m_p_l_e_t_r_a_n_s_f_o_r_m_a_t_i_o_n_d_e_s_c_r_i_p_t_o_r_s_._h_h │ │ │ │ │ +_g_e_n_e_r_i_c_t_r_a_n_s_f_o_r_m_a_t_i_o_n_d_e_s_c_r_i_p_t_o_r_s_._h_h │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00023.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: fixedcapacitystack.hh File Reference │ │ │ │ +dune-typetree: accumulate_static.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -71,37 +71,134 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ Classes | │ │ │ │ -Namespaces
    │ │ │ │ -
    fixedcapacitystack.hh File Reference
    │ │ │ │ +Namespaces | │ │ │ │ +Functions
    │ │ │ │ +
    accumulate_static.hh File Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ -
    #include <array>
    │ │ │ │ -#include <cassert>
    │ │ │ │ +
    #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>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    class  Dune::TypeTree::FixedCapacityStackView< T >
    struct  Dune::TypeTree::or_< result_type >
     Statically combine two values of type result_type using ||. More...
     
    class  Dune::TypeTree::FixedCapacityStack< T, capacity >
    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.
     
    │ │ │ │ +

    Variable Documentation

    │ │ │ │ + │ │ │ │ +

    ◆ child_result

    │ │ │ │ + │ │ │ │ +
    │ │ │ │ +
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +
    const result_type child_result = accumulate_value<child,Functor,Reduction,ParentChildReduction,current_value,child_tree_path,NodeTag<child>>::result
    │ │ │ │ +     		│ │ │ │ +static
    │ │ │ │ +
    │ │ │ │ + │ │ │ │ +
    │ │ │ │ +
    │ │ │ │ + │ │ │ │ +

    ◆ result

    │ │ │ │ + │ │ │ │ +
    │ │ │ │ +
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +
    const result_type result = current_value
    │ │ │ │ +     		│ │ │ │ +static
    │ │ │ │ +
    │ │ │ │ + │ │ │ │ +
    │ │ │ │ +
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,23 +1,84 @@ │ │ │ │ │ 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 │ │ │ │ │ -fixedcapacitystack.hh File Reference │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ +_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> │ │ │ │ │ _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 │ │ │ │ │ -class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_<_ _T_ _> │ │ │ │ │ +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_._._. │ │ │ │ │   │ │ │ │ │ -class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_<_ _T_,_ _c_a_p_a_c_i_t_y_ _> │ │ │ │ │ +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. │ │ │ │ │ +  │ │ │ │ │ +********** 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 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00023_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: fixedcapacitystack.hh Source File │ │ │ │ +dune-typetree: accumulate_static.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,215 +74,595 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -
    fixedcapacitystack.hh
    │ │ │ │ +
    accumulate_static.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ -Go to the documentation of this file.
    1// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
    │ │ │ │ -
    2// vi: set et ts=8 sw=2 sts=2:
    │ │ │ │ +Go to the documentation of this file.
    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_FIXEDCAPACITYSTACK_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_FIXEDCAPACITYSTACK_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_ACCUMULATE_STATIC_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_ACCUMULATE_STATIC_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <array>
    │ │ │ │ -
    10#include <cassert>
    │ │ │ │ -
    11
    │ │ │ │ -
    12namespace Dune {
    │ │ │ │ -
    13 namespace TypeTree {
    │ │ │ │ +
    9#include <dune/common/typetraits.hh>
    │ │ │ │ +
    10#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ +
    11#include <dune/typetree/nodetags.hh>
    │ │ │ │ +
    12#include <dune/typetree/treepath.hh>
    │ │ │ │ +
    13#include <dune/typetree/utility.hh>
    │ │ │ │
    14
    │ │ │ │
    15
    │ │ │ │ -
    19
    │ │ │ │ -
    20 template<typename T>
    │ │ │ │ -
    │ │ │ │ -
    21 class FixedCapacityStackView
    │ │ │ │ -
    22 {
    │ │ │ │ -
    23
    │ │ │ │ -
    24 public:
    │ │ │ │ -
    25
    │ │ │ │ -
    26 struct Impl
    │ │ │ │ -
    27 {
    │ │ │ │ -
    28
    │ │ │ │ -
    29 Impl(T* data, std::size_t capacity)
    │ │ │ │ -
    30 : _data(data)
    │ │ │ │ -
    31 , _size(0)
    │ │ │ │ -
    32 , _capacity(capacity)
    │ │ │ │ -
    33 {}
    │ │ │ │ +
    │ │ │ │ +
    16namespace Dune {
    │ │ │ │ +
    │ │ │ │ +
    17 namespace TypeTree {
    │ │ │ │ +
    18
    │ │ │ │ +
    25 template<typename result_type>
    │ │ │ │ +
    │ │ │ │ +
    26 struct or_
    │ │ │ │ +
    27 {
    │ │ │ │ +
    28 template<result_type r1, result_type r2>
    │ │ │ │ +
    │ │ │ │ +
    29 struct reduce
    │ │ │ │ +
    30 {
    │ │ │ │ +
    31 static const result_type result = r1 || r2;
    │ │ │ │ +
    32 };
    │ │ │ │ +
    │ │ │ │ +
    33 };
    │ │ │ │ +
    │ │ │ │
    34
    │ │ │ │ -
    35 T * const _data;
    │ │ │ │ -
    36 std::size_t _size;
    │ │ │ │ -
    37 const std::size_t _capacity;
    │ │ │ │ -
    38 };
    │ │ │ │ -
    39
    │ │ │ │ -
    │ │ │ │ -
    40 FixedCapacityStackView(Impl& impl)
    │ │ │ │ -
    41 : _impl(impl)
    │ │ │ │ -
    42 {}
    │ │ │ │ +
    36 template<typename result_type>
    │ │ │ │ +
    │ │ │ │ +
    37 struct and_
    │ │ │ │ +
    38 {
    │ │ │ │ +
    39 template<result_type r1, result_type r2>
    │ │ │ │ +
    │ │ │ │ +
    40 struct reduce
    │ │ │ │ +
    41 {
    │ │ │ │ +
    42 static const result_type result = r1 && r2;
    │ │ │ │ +
    43 };
    │ │ │ │ +
    │ │ │ │ +
    44 };
    │ │ │ │
    │ │ │ │ -
    43
    │ │ │ │ -
    44 public:
    │ │ │ │
    45
    │ │ │ │ -
    │ │ │ │ -
    46 std::size_t size() const
    │ │ │ │ -
    47 {
    │ │ │ │ -
    48 return _impl._size;
    │ │ │ │ -
    49 }
    │ │ │ │ -
    │ │ │ │ -
    50
    │ │ │ │ -
    │ │ │ │ -
    51 std::size_t capacity() const
    │ │ │ │ -
    52 {
    │ │ │ │ -
    53 return _impl._capacity;
    │ │ │ │ -
    54 }
    │ │ │ │ -
    │ │ │ │ -
    55
    │ │ │ │ -
    │ │ │ │ -
    56 bool empty() const
    │ │ │ │ -
    57 {
    │ │ │ │ -
    58 return _impl._size == 0;
    │ │ │ │ -
    59 }
    │ │ │ │ -
    │ │ │ │ -
    60
    │ │ │ │ -
    │ │ │ │ -
    61 bool full() const
    │ │ │ │ -
    62 {
    │ │ │ │ -
    63 return _impl._size == _impl._capacity;
    │ │ │ │ -
    64 }
    │ │ │ │ -
    │ │ │ │ -
    65
    │ │ │ │ -
    │ │ │ │ -
    66 void push_back(const T& t)
    │ │ │ │ -
    67 {
    │ │ │ │ -
    68 assert(!full());
    │ │ │ │ -
    69 _impl._data[_impl._size++] = t;
    │ │ │ │ -
    70 }
    │ │ │ │ -
    │ │ │ │ -
    71
    │ │ │ │ -
    │ │ │ │ -
    72 void pop_back()
    │ │ │ │ -
    73 {
    │ │ │ │ -
    74 assert(!empty());
    │ │ │ │ -
    75 --_impl._size;
    │ │ │ │ -
    76 }
    │ │ │ │ -
    │ │ │ │ -
    77
    │ │ │ │ -
    │ │ │ │ -
    78 T& back()
    │ │ │ │ -
    79 {
    │ │ │ │ -
    80 assert(!empty());
    │ │ │ │ -
    81 return _impl._data[_impl._size-1];
    │ │ │ │ -
    82 }
    │ │ │ │ -
    │ │ │ │ -
    83
    │ │ │ │ -
    │ │ │ │ -
    84 const T& back() const
    │ │ │ │ -
    85 {
    │ │ │ │ -
    86 assert(!empty());
    │ │ │ │ -
    87 return _impl._data[_impl._size-1];
    │ │ │ │ -
    88 }
    │ │ │ │ +
    47 template<typename result_type>
    │ │ │ │ +
    │ │ │ │ +
    48 struct plus
    │ │ │ │ +
    49 {
    │ │ │ │ +
    50 template<result_type r1, result_type r2>
    │ │ │ │ +
    │ │ │ │ +
    51 struct reduce
    │ │ │ │ +
    52 {
    │ │ │ │ +
    53 static const result_type result = r1 + r2;
    │ │ │ │ +
    54 };
    │ │ │ │ +
    │ │ │ │ +
    55 };
    │ │ │ │ +
    │ │ │ │ +
    56
    │ │ │ │ +
    58 template<typename result_type>
    │ │ │ │ +
    │ │ │ │ +
    59 struct minus
    │ │ │ │ +
    60 {
    │ │ │ │ +
    61 template<result_type r1, result_type r2>
    │ │ │ │ +
    │ │ │ │ +
    62 struct reduce
    │ │ │ │ +
    63 {
    │ │ │ │ +
    64 static const result_type result = r1 - r2;
    │ │ │ │ +
    65 };
    │ │ │ │ +
    │ │ │ │ +
    66 };
    │ │ │ │ +
    │ │ │ │ +
    67
    │ │ │ │ +
    69 template<typename result_type>
    │ │ │ │ +
    │ │ │ │ +
    70 struct multiply
    │ │ │ │ +
    71 {
    │ │ │ │ +
    72 template<result_type r1, result_type r2>
    │ │ │ │ +
    │ │ │ │ +
    73 struct reduce
    │ │ │ │ +
    74 {
    │ │ │ │ +
    75 static const result_type result = r1 * r2;
    │ │ │ │ +
    76 };
    │ │ │ │ +
    │ │ │ │ +
    77 };
    │ │ │ │ +
    │ │ │ │ +
    78
    │ │ │ │ +
    80 template<typename result_type>
    │ │ │ │ +
    │ │ │ │ +
    81 struct min
    │ │ │ │ +
    82 {
    │ │ │ │ +
    83 template<result_type r1, result_type r2>
    │ │ │ │ +
    │ │ │ │ +
    84 struct reduce
    │ │ │ │ +
    85 {
    │ │ │ │ +
    86 static const result_type result = r1 < r2 ? r1 : r2;
    │ │ │ │ +
    87 };
    │ │ │ │ +
    │ │ │ │ +
    88 };
    │ │ │ │
    │ │ │ │
    89
    │ │ │ │ -
    │ │ │ │ -
    90 T& front()
    │ │ │ │ -
    91 {
    │ │ │ │ -
    92 assert(!empty());
    │ │ │ │ -
    93 return _impl._data[0];
    │ │ │ │ -
    94 }
    │ │ │ │ -
    │ │ │ │ -
    95
    │ │ │ │ -
    │ │ │ │ -
    96 const T& front() const
    │ │ │ │ -
    97 {
    │ │ │ │ -
    98 assert(!empty());
    │ │ │ │ -
    99 return _impl._data[0];
    │ │ │ │ -
    100 }
    │ │ │ │ +
    91 template<typename result_type>
    │ │ │ │ +
    │ │ │ │ +
    92 struct max
    │ │ │ │ +
    93 {
    │ │ │ │ +
    94 template<result_type r1, result_type r2>
    │ │ │ │ +
    │ │ │ │ +
    95 struct reduce
    │ │ │ │ +
    96 {
    │ │ │ │ +
    97 static const result_type result = r1 > r2 ? r1 : r2;
    │ │ │ │ +
    98 };
    │ │ │ │
    │ │ │ │ +
    99 };
    │ │ │ │ +
    │ │ │ │ +
    100
    │ │ │ │
    101
    │ │ │ │ -
    │ │ │ │ -
    102 T& operator[](std::size_t k)
    │ │ │ │ -
    103 {
    │ │ │ │ -
    104 assert(k < _impl._size);
    │ │ │ │ -
    105 return _impl._data[k];
    │ │ │ │ -
    106 }
    │ │ │ │ -
    │ │ │ │ -
    107
    │ │ │ │ -
    │ │ │ │ -
    108 const T& operator[](std::size_t k) const
    │ │ │ │ -
    109 {
    │ │ │ │ -
    110 assert(k < _impl._size);
    │ │ │ │ -
    111 return _impl._data[k];
    │ │ │ │ -
    112 }
    │ │ │ │ -
    │ │ │ │ -
    113
    │ │ │ │ -
    114 private:
    │ │ │ │ -
    115 Impl& _impl;
    │ │ │ │ +
    102 namespace {
    │ │ │ │ +
    103
    │ │ │ │ +
    104 // implementation of the traversal algorithm
    │ │ │ │ +
    105
    │ │ │ │ +
    107 template<typename Node, typename Functor, typename Reduction, typename Functor::result_type current_value, typename TreePath, bool doVisit>
    │ │ │ │ +
    108 struct accumulate_node_helper
    │ │ │ │ +
    109 {
    │ │ │ │ +
    110
    │ │ │ │ +
    111 typedef typename Functor::result_type result_type;
    │ │ │ │ +
    112
    │ │ │ │ +
    113 static const result_type result = current_value;
    │ │ │ │ +
    114
    │ │ │ │ +
    115 };
    │ │ │ │
    116
    │ │ │ │ -
    117 };
    │ │ │ │ -
    │ │ │ │ -
    118
    │ │ │ │ -
    119
    │ │ │ │ -
    120 template<typename T, std::size_t capacity>
    │ │ │ │ -
    │ │ │ │ -
    121 class FixedCapacityStack
    │ │ │ │ -
    122 : private std::array<T,capacity>
    │ │ │ │ -
    123 , private FixedCapacityStackView<T>::Impl
    │ │ │ │ -
    124 , public FixedCapacityStackView<T>
    │ │ │ │ -
    125 {
    │ │ │ │ -
    126
    │ │ │ │ -
    127 typedef FixedCapacityStackView<T> view_base;
    │ │ │ │ -
    128
    │ │ │ │ -
    129 public:
    │ │ │ │ -
    130
    │ │ │ │ -
    131 using view_base::back;
    │ │ │ │ -
    132 using view_base::front;
    │ │ │ │ -
    133 using view_base::size;
    │ │ │ │ -
    134 using view_base::operator[];
    │ │ │ │ -
    135
    │ │ │ │ -
    │ │ │ │ -
    136 FixedCapacityStack()
    │ │ │ │ -
    137 : FixedCapacityStackView<T>::Impl(&(static_cast<std::array<T,capacity>&>(*this)[0]),capacity)
    │ │ │ │ -
    138 , FixedCapacityStackView<T>(static_cast<typename FixedCapacityStackView<T>::Impl&>(*this))
    │ │ │ │ -
    139 {}
    │ │ │ │ -
    │ │ │ │ +
    118 template<typename Node, typename Functor, typename Reduction, typename Functor::result_type current_value, typename TreePath>
    │ │ │ │ +
    119 struct accumulate_node_helper<Node,Functor,Reduction,current_value,TreePath,true>
    │ │ │ │ +
    120 {
    │ │ │ │ +
    121
    │ │ │ │ +
    122 typedef typename Functor::result_type result_type;
    │ │ │ │ +
    123
    │ │ │ │ +
    124 static const result_type result = Reduction::template reduce<current_value,Functor::template visit<Node,TreePath>::result>::result;
    │ │ │ │ +
    125
    │ │ │ │ +
    126 };
    │ │ │ │ +
    127
    │ │ │ │ +
    129 template<typename Tree, typename Functor, typename Reduction, typename ParentChildReduction, typename Functor::result_type current_value, typename TreePath, typename Tag>
    │ │ │ │ +
    130 struct accumulate_value;
    │ │ │ │ +
    131
    │ │ │ │ +
    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>
    │ │ │ │ +
    135 {
    │ │ │ │ +
    136
    │ │ │ │ +
    137 typedef typename Functor::result_type result_type;
    │ │ │ │ +
    138
    │ │ │ │ +
    139 static const result_type result =
    │ │ │ │
    140
    │ │ │ │ -
    141 private:
    │ │ │ │ +
    141 accumulate_node_helper<LeafNode,Functor,Reduction,current_value,TreePath,Functor::template doVisit<LeafNode,TreePath>::value>::result;
    │ │ │ │
    142
    │ │ │ │ -
    143 //FixedCapacityStack(const FixedCapacityStack&);
    │ │ │ │ -
    144 FixedCapacityStack& operator=(const FixedCapacityStack&);
    │ │ │ │ -
    145
    │ │ │ │ -
    146 };
    │ │ │ │ -
    │ │ │ │ -
    147
    │ │ │ │ +
    143 };
    │ │ │ │ +
    144
    │ │ │ │ +
    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>
    │ │ │ │ +
    147 struct accumulate_over_children
    │ │ │ │ +
    148 {
    │ │ │ │
    149
    │ │ │ │ -
    150 } // namespace TypeTree
    │ │ │ │ -
    151} //namespace Dune
    │ │ │ │ -
    152
    │ │ │ │ -
    153#endif // DUNE_TYPETREE_FIXEDCAPACITYSTACK_HH
    │ │ │ │ +
    150 typedef typename Functor::result_type result_type;
    │ │ │ │ +
    151
    │ │ │ │ +
    152 typedef decltype(push_back(TreePath{},index_constant<i>{})) child_tree_path;
    │ │ │ │ +
    153
    │ │ │ │ +
    154 typedef typename Node::template Child<i>::Type child;
    │ │ │ │ +
    155
    │ │ │ │ +
    156 static const result_type child_result = accumulate_value<child,Functor,Reduction,ParentChildReduction,current_value,child_tree_path,NodeTag<child>>::result;
    │ │ │ │ +
    157
    │ │ │ │ +
    158 static const result_type result = accumulate_over_children<Node,Functor,Reduction,ParentChildReduction,child_result,TreePath,i+1,n>::result;
    │ │ │ │ +
    159
    │ │ │ │ +
    160 };
    │ │ │ │ +
    161
    │ │ │ │ +
    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>
    │ │ │ │ +
    165 {
    │ │ │ │ +
    166
    │ │ │ │ +
    167 typedef typename Functor::result_type result_type;
    │ │ │ │ +
    168
    │ │ │ │ +
    169 static const result_type result = current_value;
    │ │ │ │ +
    170
    │ │ │ │ +
    171 };
    │ │ │ │ +
    172
    │ │ │ │ +
    175 template<typename Node, typename Functor, typename Reduction, typename ParentChildReduction, typename Functor::result_type current_value, typename TreePath>
    │ │ │ │ +
    176 struct accumulate_value_generic_composite_node
    │ │ │ │ +
    177 {
    │ │ │ │ +
    178
    │ │ │ │ +
    179 typedef typename Functor::result_type result_type;
    │ │ │ │ +
    180
    │ │ │ │ +
    181 static const result_type child_result = accumulate_over_children<Node,Functor,Reduction,ParentChildReduction,current_value,TreePath,0,StaticDegree<Node>::value>::result;
    │ │ │ │ +
    182
    │ │ │ │ +
    183 static const result_type result =
    │ │ │ │ +
    184 accumulate_node_helper<Node,Functor,ParentChildReduction,child_result,TreePath,Functor::template doVisit<Node,TreePath>::value>::result;
    │ │ │ │ +
    185
    │ │ │ │ +
    186
    │ │ │ │ +
    187 };
    │ │ │ │ +
    188
    │ │ │ │ +
    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>
    │ │ │ │ +
    193 {};
    │ │ │ │ +
    194
    │ │ │ │ +
    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>
    │ │ │ │ +
    199 {};
    │ │ │ │ +
    200
    │ │ │ │ +
    201 } // anonymous namespace
    │ │ │ │ +
    202
    │ │ │ │ +
    204
    │ │ │ │ +
    260 template<typename Tree, typename Functor, typename Reduction, typename Functor::result_type startValue, typename ParentChildReduction = Reduction>
    │ │ │ │ +
    │ │ │ │ +
    261 struct AccumulateValue
    │ │ │ │ +
    262 {
    │ │ │ │ +
    263
    │ │ │ │ +
    265 typedef typename Functor::result_type result_type;
    │ │ │ │ +
    266
    │ │ │ │ +
    268 static const result_type result = accumulate_value<Tree,Functor,Reduction,ParentChildReduction,startValue,HybridTreePath<>,NodeTag<Tree>>::result;
    │ │ │ │ +
    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<typename Node, typename Functor, typename Reduction, typename current_type, typename TreePath, bool doVisit>
    │ │ │ │ +
    287 struct accumulate_type_node_helper
    │ │ │ │ +
    288 {
    │ │ │ │ +
    289
    │ │ │ │ +
    290 typedef current_type type;
    │ │ │ │ +
    291
    │ │ │ │ +
    292 };
    │ │ │ │ +
    293
    │ │ │ │ +
    295 template<typename Node, typename Functor, typename Reduction, typename current_type, typename TreePath>
    │ │ │ │ +
    296 struct accumulate_type_node_helper<Node,Functor,Reduction,current_type,TreePath,true>
    │ │ │ │ +
    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<typename Tree, typename Policy, typename current_type, typename TreePath, typename Tag>
    │ │ │ │ +
    311 struct accumulate_type;
    │ │ │ │ +
    312
    │ │ │ │ +
    314 template<typename LeafNode, typename Policy, typename current_type, typename TreePath>
    │ │ │ │ +
    315 struct accumulate_type<LeafNode,Policy,current_type,TreePath,LeafNodeTag>
    │ │ │ │ +
    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<typename current_type, typename tree_path, typename start_type, typename reduction_strategy>
    │ │ │ │ +
    335 struct propagate_type_down_tree;
    │ │ │ │ +
    336
    │ │ │ │ +
    338 template<typename current_type, typename tree_path, typename start_type>
    │ │ │ │ +
    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<typename current_type, typename tree_path, typename start_type>
    │ │ │ │ +
    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<tree_path>::value == 0,
    │ │ │ │ +
    360 start_type,
    │ │ │ │ +
    361 current_type
    │ │ │ │ +
    362 >::type type;
    │ │ │ │ +
    363 };
    │ │ │ │ +
    364
    │ │ │ │ +
    365
    │ │ │ │ +
    367 template<typename Node, typename Policy, typename current_type, typename TreePath, std::size_t i, std::size_t n>
    │ │ │ │ +
    368 struct accumulate_type_over_children
    │ │ │ │ +
    369 {
    │ │ │ │ +
    370
    │ │ │ │ +
    371 typedef decltype(push_back(TreePath{},index_constant<i>{})) child_tree_path;
    │ │ │ │ +
    372
    │ │ │ │ +
    373 typedef typename Node::template Child<i>::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<child>
    │ │ │ │ +
    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<typename Node, typename Policy, typename current_type, typename TreePath, std::size_t n>
    │ │ │ │ +
    402 struct accumulate_type_over_children<Node,Policy,current_type,TreePath,n,n>
    │ │ │ │ +
    403 {
    │ │ │ │ +
    404
    │ │ │ │ +
    405 typedef current_type type;
    │ │ │ │ +
    406
    │ │ │ │ +
    407 };
    │ │ │ │ +
    408
    │ │ │ │ +
    409
    │ │ │ │ +
    412 template<typename Node, typename Policy, typename current_type, typename TreePath>
    │ │ │ │ +
    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<Node>::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<typename PowerNode, typename Policy, typename current_type, typename TreePath>
    │ │ │ │ +
    441 struct accumulate_type<PowerNode,Policy,current_type,TreePath,PowerNodeTag>
    │ │ │ │ +
    442 : public accumulate_type_generic_composite_node<PowerNode,Policy,current_type,TreePath>
    │ │ │ │ +
    443 {};
    │ │ │ │ +
    444
    │ │ │ │ +
    446 template<typename CompositeNode, typename Policy, typename current_type, typename TreePath>
    │ │ │ │ +
    447 struct accumulate_type<CompositeNode,Policy,current_type,TreePath,CompositeNodeTag>
    │ │ │ │ +
    448 : public accumulate_type_generic_composite_node<CompositeNode,Policy,current_type,TreePath>
    │ │ │ │ +
    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 >
    │ │ │ │ +
    │ │ │ │ +
    468 struct TypeAccumulationPolicy
    │ │ │ │ +
    469 {
    │ │ │ │ +
    470
    │ │ │ │ +
    498 typedef Functor functor;
    │ │ │ │ +
    499
    │ │ │ │ +
    519 typedef Reduction sibling_reduction;
    │ │ │ │ +
    520
    │ │ │ │ +
    527 typedef ParentChildReduction parent_child_reduction;
    │ │ │ │ +
    528
    │ │ │ │ +
    535 typedef StartType start_type;
    │ │ │ │ +
    536
    │ │ │ │ +
    541 typedef ReductionAlgorithm reduction_strategy;
    │ │ │ │ +
    542 };
    │ │ │ │ +
    │ │ │ │ +
    543
    │ │ │ │ +
    544
    │ │ │ │ +
    546
    │ │ │ │ +
    554 template<typename Tree, typename Policy>
    │ │ │ │ +
    │ │ │ │ +
    555 struct AccumulateType
    │ │ │ │ +
    556 {
    │ │ │ │ +
    557
    │ │ │ │ +
    559 typedef typename accumulate_type<
    │ │ │ │ +
    560 Tree,
    │ │ │ │ +
    561 Policy,
    │ │ │ │ +
    562 typename Policy::start_type,
    │ │ │ │ +
    563 HybridTreePath<>,
    │ │ │ │ +
    564 NodeTag<Tree>
    │ │ │ │ +
    565 >::type type;
    │ │ │ │ +
    566
    │ │ │ │ +
    567 };
    │ │ │ │ +
    │ │ │ │ +
    568
    │ │ │ │ +
    569
    │ │ │ │ +
    570
    │ │ │ │ +
    571
    │ │ │ │ +
    572
    │ │ │ │ +
    573 /***************************************************/
    │ │ │ │ +
    574
    │ │ │ │ +
    │ │ │ │ +
    575 namespace Experimental {
    │ │ │ │ +
    576 namespace Impl {
    │ │ │ │ +
    577
    │ │ │ │ +
    579 template<class T, class TreePath, class V, class U,
    │ │ │ │ +
    580 std::enable_if_t<std::decay_t<T>::isLeaf, int> = 0>
    │ │ │ │ +
    581 auto hybridApplyToTree(T&& tree, TreePath treePath, V&& visitor, U&& current_val)
    │ │ │ │ +
    582 {
    │ │ │ │ +
    583 return visitor.leaf(tree, treePath, std::forward<U>(current_val));
    │ │ │ │ +
    584 }
    │ │ │ │ +
    585
    │ │ │ │ +
    587 template<class T, class TreePath, class V, class U,
    │ │ │ │ +
    588 std::enable_if_t<not std::decay_t<T>::isLeaf, int> = 0>
    │ │ │ │ +
    589 auto hybridApplyToTree(T&& tree, TreePath treePath, V&& visitor, U&& current_val)
    │ │ │ │ +
    590 {
    │ │ │ │ +
    591 using Tree = std::remove_reference_t<T>;
    │ │ │ │ +
    592 using Visitor = std::remove_reference_t<V>;
    │ │ │ │ +
    593 auto pre_val = visitor.pre(tree, treePath, std::forward<U>(current_val));
    │ │ │ │ +
    594
    │ │ │ │ +
    595 // check which type of traversal is supported by the tree
    │ │ │ │ +
    596 using allowDynamicTraversal = Dune::Std::is_detected<Detail::DynamicTraversalConcept,Tree>;
    │ │ │ │ +
    597 using allowStaticTraversal = Dune::Std::is_detected<Detail::StaticTraversalConcept,Tree>;
    │ │ │ │ +
    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<Visitor::treePathType == TreePathType::dynamic>;
    │ │ │ │ +
    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&& child = tree.child(i);
    │ │ │ │ +
    608 using Child = std::decay_t<decltype(child)>;
    │ │ │ │ +
    609
    │ │ │ │ +
    610 auto val_before = visitor.beforeChild(tree, child, treePath, 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, treePath, std::move(val_before));}
    │ │ │ │ +
    617 );
    │ │ │ │ +
    618
    │ │ │ │ +
    619 constexpr bool visitChild = Visitor::template VisitChild<Tree,Child,TreePath>::value;
    │ │ │ │ +
    620 auto val_visit = [&](){
    │ │ │ │ +
    621 if constexpr (visitChild) {
    │ │ │ │ +
    622 auto childTreePath = Dune::TypeTree::push_back(treePath, i);
    │ │ │ │ +
    623 return hybridApplyToTree(child, childTreePath, visitor, std::move(val_in));
    │ │ │ │ +
    624 }
    │ │ │ │ +
    625 else
    │ │ │ │ +
    626 return std::move(val_in);
    │ │ │ │ +
    627 }();
    │ │ │ │ +
    628
    │ │ │ │ +
    629 return visitor.afterChild(tree, child, treePath, 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<Tree::degree()>{};
    │ │ │ │ +
    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, treePath, in_val);
    │ │ │ │ +
    673 }
    │ │ │ │ +
    674
    │ │ │ │ +
    675 }
    │ │ │ │ +
    676
    │ │ │ │ +
    700 template<typename Tree, typename Visitor, typename Init>
    │ │ │ │ +
    │ │ │ │ +
    701 auto hybridApplyToTree(Tree&& tree, Visitor&& visitor, Init&& init)
    │ │ │ │ +
    702 {
    │ │ │ │ +
    703 return Impl::hybridApplyToTree(tree, hybridTreePath(), visitor, init);
    │ │ │ │ +
    704 }
    │ │ │ │ +
    │ │ │ │ +
    705
    │ │ │ │ +
    706 } // namespace Experimental
    │ │ │ │ +
    │ │ │ │ +
    707
    │ │ │ │ +
    709 } // namespace TypeTree
    │ │ │ │ +
    │ │ │ │ +
    710} //namespace Dune
    │ │ │ │ +
    │ │ │ │ +
    711
    │ │ │ │ +
    712#endif // DUNE_TYPETREE_ACCUMULATE_STATIC_HH
    │ │ │ │ +
    child_result
    static const result_type child_result
    Definition accumulate_static.hh:156
    │ │ │ │ +
    result
    static const result_type result
    Definition accumulate_static.hh:113
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::Child
    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
    │ │ │ │ +
    Dune::TypeTree::child
    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
    │ │ │ │ +
    Dune::TypeTree::NodeTag
    typename std::decay_t< Node >::NodeTag NodeTag
    Returns the node tag of the given Node.
    Definition nodeinterface.hh:70
    │ │ │ │ +
    Dune::TypeTree::push_back
    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
    │ │ │ │ +
    Dune::TypeTree::hybridTreePath
    constexpr auto hybridTreePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:312
    │ │ │ │ +
    Dune::TypeTree::treePath
    constexpr auto treePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:326
    │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::FixedCapacityStackView
    Definition fixedcapacitystack.hh:22
    │ │ │ │ -
    Dune::TypeTree::FixedCapacityStackView::empty
    bool empty() const
    Definition fixedcapacitystack.hh:56
    │ │ │ │ -
    Dune::TypeTree::FixedCapacityStackView::full
    bool full() const
    Definition fixedcapacitystack.hh:61
    │ │ │ │ -
    Dune::TypeTree::FixedCapacityStackView::operator[]
    T & operator[](std::size_t k)
    Definition fixedcapacitystack.hh:102
    │ │ │ │ -
    Dune::TypeTree::FixedCapacityStackView::pop_back
    void pop_back()
    Definition fixedcapacitystack.hh:72
    │ │ │ │ -
    Dune::TypeTree::FixedCapacityStackView::back
    T & back()
    Definition fixedcapacitystack.hh:78
    │ │ │ │ -
    Dune::TypeTree::FixedCapacityStackView::capacity
    std::size_t capacity() const
    Definition fixedcapacitystack.hh:51
    │ │ │ │ -
    Dune::TypeTree::FixedCapacityStackView::front
    T & front()
    Definition fixedcapacitystack.hh:90
    │ │ │ │ -
    Dune::TypeTree::FixedCapacityStackView::front
    const T & front() const
    Definition fixedcapacitystack.hh:96
    │ │ │ │ -
    Dune::TypeTree::FixedCapacityStackView::operator[]
    const T & operator[](std::size_t k) const
    Definition fixedcapacitystack.hh:108
    │ │ │ │ -
    Dune::TypeTree::FixedCapacityStackView::push_back
    void push_back(const T &t)
    Definition fixedcapacitystack.hh:66
    │ │ │ │ -
    Dune::TypeTree::FixedCapacityStackView::back
    const T & back() const
    Definition fixedcapacitystack.hh:84
    │ │ │ │ -
    Dune::TypeTree::FixedCapacityStackView::size
    std::size_t size() const
    Definition fixedcapacitystack.hh:46
    │ │ │ │ -
    Dune::TypeTree::FixedCapacityStackView::FixedCapacityStackView
    FixedCapacityStackView(Impl &impl)
    Definition fixedcapacitystack.hh:40
    │ │ │ │ -
    Dune::TypeTree::FixedCapacityStack
    Definition fixedcapacitystack.hh:125
    │ │ │ │ -
    Dune::TypeTree::FixedCapacityStack::FixedCapacityStack
    FixedCapacityStack()
    Definition fixedcapacitystack.hh:136
    │ │ │ │ +
    Dune::TypeTree::or_
    Statically combine two values of type result_type using ||.
    Definition accumulate_static.hh:27
    │ │ │ │ +
    Dune::TypeTree::or_::reduce
    Definition accumulate_static.hh:30
    │ │ │ │ +
    Dune::TypeTree::or_::reduce::result
    static const result_type result
    Definition accumulate_static.hh:31
    │ │ │ │ +
    Dune::TypeTree::and_
    Statically combine two values of type result_type using &&.
    Definition accumulate_static.hh:38
    │ │ │ │ +
    Dune::TypeTree::and_::reduce
    Definition accumulate_static.hh:41
    │ │ │ │ +
    Dune::TypeTree::and_::reduce::result
    static const result_type result
    Definition accumulate_static.hh:42
    │ │ │ │ +
    Dune::TypeTree::plus
    Statically combine two values of type result_type using +.
    Definition accumulate_static.hh:49
    │ │ │ │ +
    Dune::TypeTree::plus::reduce
    Definition accumulate_static.hh:52
    │ │ │ │ +
    Dune::TypeTree::plus::reduce::result
    static const result_type result
    Definition accumulate_static.hh:53
    │ │ │ │ +
    Dune::TypeTree::minus
    Statically combine two values of type result_type using -.
    Definition accumulate_static.hh:60
    │ │ │ │ +
    Dune::TypeTree::minus::reduce
    Definition accumulate_static.hh:63
    │ │ │ │ +
    Dune::TypeTree::minus::reduce::result
    static const result_type result
    Definition accumulate_static.hh:64
    │ │ │ │ +
    Dune::TypeTree::multiply
    Statically combine two values of type result_type using *.
    Definition accumulate_static.hh:71
    │ │ │ │ +
    Dune::TypeTree::multiply::reduce
    Definition accumulate_static.hh:74
    │ │ │ │ +
    Dune::TypeTree::multiply::reduce::result
    static const result_type result
    Definition accumulate_static.hh:75
    │ │ │ │ +
    Dune::TypeTree::min
    Statically combine two values of type result_type by returning their minimum.
    Definition accumulate_static.hh:82
    │ │ │ │ +
    Dune::TypeTree::min::reduce
    Definition accumulate_static.hh:85
    │ │ │ │ +
    Dune::TypeTree::min::reduce::result
    static const result_type result
    Definition accumulate_static.hh:86
    │ │ │ │ +
    Dune::TypeTree::max
    Statically combine two values of type result_type by returning their maximum.
    Definition accumulate_static.hh:93
    │ │ │ │ +
    Dune::TypeTree::max::reduce
    Definition accumulate_static.hh:96
    │ │ │ │ +
    Dune::TypeTree::max::reduce::result
    static const result_type result
    Definition accumulate_static.hh:97
    │ │ │ │ +
    Dune::TypeTree::AccumulateValue
    Statically accumulate a value over the nodes of a TypeTree.
    Definition accumulate_static.hh:262
    │ │ │ │ +
    Dune::TypeTree::AccumulateValue::result_type
    Functor::result_type result_type
    The result type of the computation.
    Definition accumulate_static.hh:265
    │ │ │ │ +
    Dune::TypeTree::AccumulateValue::result
    static const result_type result
    The accumulated result of the computation.
    Definition accumulate_static.hh:268
    │ │ │ │ +
    Dune::TypeTree::TypeAccumulationPolicy
    Definition accumulate_static.hh:469
    │ │ │ │ +
    Dune::TypeTree::TypeAccumulationPolicy::parent_child_reduction
    ParentChildReduction parent_child_reduction
    Definition accumulate_static.hh:527
    │ │ │ │ +
    Dune::TypeTree::TypeAccumulationPolicy::functor
    Functor functor
    Definition accumulate_static.hh:498
    │ │ │ │ +
    Dune::TypeTree::TypeAccumulationPolicy::start_type
    StartType start_type
    Definition accumulate_static.hh:535
    │ │ │ │ +
    Dune::TypeTree::TypeAccumulationPolicy::reduction_strategy
    ReductionAlgorithm reduction_strategy
    Definition accumulate_static.hh:541
    │ │ │ │ +
    Dune::TypeTree::TypeAccumulationPolicy::sibling_reduction
    Reduction sibling_reduction
    Definition accumulate_static.hh:519
    │ │ │ │ +
    Dune::TypeTree::AccumulateType
    Statically accumulate a type over the nodes of a TypeTree.
    Definition accumulate_static.hh:556
    │ │ │ │ +
    Dune::TypeTree::AccumulateType::type
    accumulate_type< Tree, Policy, typenamePolicy::start_type, HybridTreePath<>, NodeTag< Tree > >::type type
    The accumulated result of the computation.
    Definition accumulate_static.hh:565
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath
    A hybrid version of TreePath that supports both compile time and run time indices.
    Definition treepath.hh:158
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,211 +1,698 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -fixedcapacitystack.hh │ │ │ │ │ +accumulate_static.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: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- │ │ │ │ │ -2// vi: set et ts=8 sw=2 sts=2: │ │ │ │ │ +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_FIXEDCAPACITYSTACK_HH │ │ │ │ │ -7#define DUNE_TYPETREE_FIXEDCAPACITYSTACK_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_ACCUMULATE_STATIC_HH │ │ │ │ │ +7#define DUNE_TYPETREE_ACCUMULATE_STATIC_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include │ │ │ │ │ -10#include │ │ │ │ │ -11 │ │ │ │ │ -12namespace _D_u_n_e { │ │ │ │ │ -13 namespace TypeTree { │ │ │ │ │ +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 │ │ │ │ │ -19 │ │ │ │ │ -20 template │ │ │ │ │ -_2_1 class _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w │ │ │ │ │ -22 { │ │ │ │ │ -23 │ │ │ │ │ -24 public: │ │ │ │ │ -25 │ │ │ │ │ -26 struct Impl │ │ │ │ │ +_1_6namespace _D_u_n_e { │ │ │ │ │ +_1_7 namespace TypeTree { │ │ │ │ │ +18 │ │ │ │ │ +25 template │ │ │ │ │ +_2_6 struct _o_r__ │ │ │ │ │ 27 { │ │ │ │ │ -28 │ │ │ │ │ -29 Impl(T* data, std::size_t _c_a_p_a_c_i_t_y) │ │ │ │ │ -30 : _data(data) │ │ │ │ │ -31 , _size(0) │ │ │ │ │ -32 , _capacity(_c_a_p_a_c_i_t_y) │ │ │ │ │ -33 {} │ │ │ │ │ +28 template │ │ │ │ │ +_2_9 struct _r_e_d_u_c_e │ │ │ │ │ +30 { │ │ │ │ │ +_3_1 static const result_type _r_e_s_u_l_t = r1 || r2; │ │ │ │ │ +32 }; │ │ │ │ │ +33 }; │ │ │ │ │ 34 │ │ │ │ │ -35 T * const _data; │ │ │ │ │ -36 std::size_t _size; │ │ │ │ │ -37 const std::size_t _capacity; │ │ │ │ │ -38 }; │ │ │ │ │ -39 │ │ │ │ │ -_4_0 _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w(Impl& impl) │ │ │ │ │ -41 : _impl(impl) │ │ │ │ │ -42 {} │ │ │ │ │ -43 │ │ │ │ │ -44 public: │ │ │ │ │ +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 }; │ │ │ │ │ 45 │ │ │ │ │ -_4_6 std::size_t _s_i_z_e() const │ │ │ │ │ -47 { │ │ │ │ │ -48 return _impl._size; │ │ │ │ │ -49 } │ │ │ │ │ -50 │ │ │ │ │ -_5_1 std::size_t _c_a_p_a_c_i_t_y() const │ │ │ │ │ +47 template │ │ │ │ │ +_4_8 struct _p_l_u_s │ │ │ │ │ +49 { │ │ │ │ │ +50 template │ │ │ │ │ +_5_1 struct _r_e_d_u_c_e │ │ │ │ │ 52 { │ │ │ │ │ -53 return _impl._capacity; │ │ │ │ │ -54 } │ │ │ │ │ -55 │ │ │ │ │ -_5_6 bool _e_m_p_t_y() const │ │ │ │ │ -57 { │ │ │ │ │ -58 return _impl._size == 0; │ │ │ │ │ -59 } │ │ │ │ │ -60 │ │ │ │ │ -_6_1 bool _f_u_l_l() const │ │ │ │ │ -62 { │ │ │ │ │ -63 return _impl._size == _impl._capacity; │ │ │ │ │ -64 } │ │ │ │ │ -65 │ │ │ │ │ -_6_6 void _p_u_s_h___b_a_c_k(const T& t) │ │ │ │ │ -67 { │ │ │ │ │ -68 assert(!_f_u_l_l()); │ │ │ │ │ -69 _impl._data[_impl._size++] = t; │ │ │ │ │ -70 } │ │ │ │ │ -71 │ │ │ │ │ -_7_2 void _p_o_p___b_a_c_k() │ │ │ │ │ -73 { │ │ │ │ │ -74 assert(!_e_m_p_t_y()); │ │ │ │ │ -75 --_impl._size; │ │ │ │ │ -76 } │ │ │ │ │ -77 │ │ │ │ │ -_7_8 T& _b_a_c_k() │ │ │ │ │ -79 { │ │ │ │ │ -80 assert(!_e_m_p_t_y()); │ │ │ │ │ -81 return _impl._data[_impl._size-1]; │ │ │ │ │ -82 } │ │ │ │ │ -83 │ │ │ │ │ -_8_4 const T& _b_a_c_k() const │ │ │ │ │ +_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 { │ │ │ │ │ -86 assert(!_e_m_p_t_y()); │ │ │ │ │ -87 return _impl._data[_impl._size-1]; │ │ │ │ │ -88 } │ │ │ │ │ +_8_6 static const result_type _r_e_s_u_l_t = r1 < r2 ? r1 : r2; │ │ │ │ │ +87 }; │ │ │ │ │ +88 }; │ │ │ │ │ 89 │ │ │ │ │ -_9_0 T& _f_r_o_n_t() │ │ │ │ │ -91 { │ │ │ │ │ -92 assert(!_e_m_p_t_y()); │ │ │ │ │ -93 return _impl._data[0]; │ │ │ │ │ -94 } │ │ │ │ │ -95 │ │ │ │ │ -_9_6 const T& _f_r_o_n_t() const │ │ │ │ │ -97 { │ │ │ │ │ -98 assert(!_e_m_p_t_y()); │ │ │ │ │ -99 return _impl._data[0]; │ │ │ │ │ -100 } │ │ │ │ │ +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 │ │ │ │ │ -_1_0_2 T& _o_p_e_r_a_t_o_r_[_](std::size_t k) │ │ │ │ │ -103 { │ │ │ │ │ -104 assert(k < _impl._size); │ │ │ │ │ -105 return _impl._data[k]; │ │ │ │ │ -106 } │ │ │ │ │ -107 │ │ │ │ │ -_1_0_8 const T& _o_p_e_r_a_t_o_r_[_](std::size_t k) const │ │ │ │ │ +102 namespace { │ │ │ │ │ +103 │ │ │ │ │ +104 // implementation of the traversal algorithm │ │ │ │ │ +105 │ │ │ │ │ +107 template │ │ │ │ │ +108 struct accumulate_node_helper │ │ │ │ │ 109 { │ │ │ │ │ -110 assert(k < _impl._size); │ │ │ │ │ -111 return _impl._data[k]; │ │ │ │ │ -112 } │ │ │ │ │ -113 │ │ │ │ │ -114 private: │ │ │ │ │ -115 Impl& _impl; │ │ │ │ │ +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 │ │ │ │ │ -117 }; │ │ │ │ │ -118 │ │ │ │ │ -119 │ │ │ │ │ -120 template │ │ │ │ │ -_1_2_1 class _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k │ │ │ │ │ -122 : private std::array │ │ │ │ │ -123 , private _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w::Impl │ │ │ │ │ -124 , public _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w │ │ │ │ │ -125 { │ │ │ │ │ -126 │ │ │ │ │ -127 typedef _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_<_T_> _v_i_e_w___b_a_s_e; │ │ │ │ │ -128 │ │ │ │ │ -129 public: │ │ │ │ │ -130 │ │ │ │ │ -131 using _v_i_e_w___b_a_s_e_:_:_b_a_c_k; │ │ │ │ │ -132 using _v_i_e_w___b_a_s_e_:_:_f_r_o_n_t; │ │ │ │ │ -133 using _v_i_e_w___b_a_s_e_:_:_s_i_z_e; │ │ │ │ │ -134 using view_base::operator[]; │ │ │ │ │ -135 │ │ │ │ │ -_1_3_6 _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k() │ │ │ │ │ -137 : _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w::Impl(&(static_cast&> │ │ │ │ │ -(*this)[0]),_c_a_p_a_c_i_t_y) │ │ │ │ │ -138 , _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w(static_cast::Impl&>(*this)) │ │ │ │ │ -139 {} │ │ │ │ │ +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 private: │ │ │ │ │ +141 │ │ │ │ │ +accumulate_node_helper::value>_:_:_r_e_s_u_l_t; │ │ │ │ │ 142 │ │ │ │ │ -143 //FixedCapacityStack(const FixedCapacityStack&); │ │ │ │ │ -144 _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k& operator=(const _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k&); │ │ │ │ │ -145 │ │ │ │ │ -146 }; │ │ │ │ │ -147 │ │ │ │ │ +143 }; │ │ │ │ │ +144 │ │ │ │ │ +146 template │ │ │ │ │ +147 struct accumulate_over_children │ │ │ │ │ +148 { │ │ │ │ │ 149 │ │ │ │ │ -150 } // namespace TypeTree │ │ │ │ │ -151} //namespace Dune │ │ │ │ │ -152 │ │ │ │ │ -153#endif // DUNE_TYPETREE_FIXEDCAPACITYSTACK_HH │ │ │ │ │ +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 │ │ │ │ │ +_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_t_a_g_s_._h_h │ │ │ │ │ +_n_o_d_e_i_n_t_e_r_f_a_c_e_._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 │ │ │ │ │ +_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_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w │ │ │ │ │ -DDeeffiinniittiioonn fixedcapacitystack.hh:22 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_e_m_p_t_y │ │ │ │ │ -bool empty() const │ │ │ │ │ -DDeeffiinniittiioonn fixedcapacitystack.hh:56 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_f_u_l_l │ │ │ │ │ -bool full() const │ │ │ │ │ -DDeeffiinniittiioonn fixedcapacitystack.hh:61 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_o_p_e_r_a_t_o_r_[_] │ │ │ │ │ -T & operator[](std::size_t k) │ │ │ │ │ -DDeeffiinniittiioonn fixedcapacitystack.hh:102 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_p_o_p___b_a_c_k │ │ │ │ │ -void pop_back() │ │ │ │ │ -DDeeffiinniittiioonn fixedcapacitystack.hh:72 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_b_a_c_k │ │ │ │ │ -T & back() │ │ │ │ │ -DDeeffiinniittiioonn fixedcapacitystack.hh:78 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_c_a_p_a_c_i_t_y │ │ │ │ │ -std::size_t capacity() const │ │ │ │ │ -DDeeffiinniittiioonn fixedcapacitystack.hh:51 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_f_r_o_n_t │ │ │ │ │ -T & front() │ │ │ │ │ -DDeeffiinniittiioonn fixedcapacitystack.hh:90 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_f_r_o_n_t │ │ │ │ │ -const T & front() const │ │ │ │ │ -DDeeffiinniittiioonn fixedcapacitystack.hh:96 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_o_p_e_r_a_t_o_r_[_] │ │ │ │ │ -const T & operator[](std::size_t k) const │ │ │ │ │ -DDeeffiinniittiioonn fixedcapacitystack.hh:108 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_p_u_s_h___b_a_c_k │ │ │ │ │ -void push_back(const T &t) │ │ │ │ │ -DDeeffiinniittiioonn fixedcapacitystack.hh:66 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_b_a_c_k │ │ │ │ │ -const T & back() const │ │ │ │ │ -DDeeffiinniittiioonn fixedcapacitystack.hh:84 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_s_i_z_e │ │ │ │ │ -std::size_t size() const │ │ │ │ │ -DDeeffiinniittiioonn fixedcapacitystack.hh:46 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w │ │ │ │ │ -FixedCapacityStackView(Impl &impl) │ │ │ │ │ -DDeeffiinniittiioonn fixedcapacitystack.hh:40 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k │ │ │ │ │ -DDeeffiinniittiioonn fixedcapacitystack.hh:125 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k │ │ │ │ │ -FixedCapacityStack() │ │ │ │ │ -DDeeffiinniittiioonn fixedcapacitystack.hh:136 │ │ │ │ │ +_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 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00026.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: compositenode.hh File Reference │ │ │ │ +dune-typetree: dynamicpowernode.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -72,33 +72,33 @@ │ │ │ │
  • dune
  • typetree
    • │ │ │ │
    │ │ │ │
    │ │ │ │
    │ │ │ │
    │ │ │ │ Classes | │ │ │ │ Namespaces
    │ │ │ │ -
    compositenode.hh File Reference
    │ │ │ │ +
    dynamicpowernode.hh File Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │ -
    #include <tuple>
    │ │ │ │ +
    #include <cassert>
    │ │ │ │ +#include <vector>
    │ │ │ │ #include <memory>
    │ │ │ │ #include <type_traits>
    │ │ │ │ -#include <dune/typetree/nodetags.hh>
    │ │ │ │ -#include <dune/typetree/childextraction.hh>
    │ │ │ │ -#include <dune/typetree/typetraits.hh>
    │ │ │ │ +#include <dune/common/typetraits.hh>
    │ │ │ │ +#include <dune/common/std/type_traits.hh>
    │ │ │ │ +#include <dune/typetree/nodetags.hh>
    │ │ │ │ +#include <dune/typetree/utility.hh>
    │ │ │ │ +#include <dune/typetree/typetraits.hh>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    class  Dune::TypeTree::CompositeNode< Children >
     Base class for composite nodes based on variadic templates. More...
     
    struct  Dune::TypeTree::CompositeNode< Children >::Child< k >
     Access to the type and storage type of the i-th child. More...
    class  Dune::TypeTree::DynamicPowerNode< T >
     Collect multiple instances of type T within a dune-typetree. More...
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,28 +1,28 @@ │ │ │ │ │ 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 │ │ │ │ │ -compositenode.hh File Reference │ │ │ │ │ -#include │ │ │ │ │ +dynamicpowernode.hh File Reference │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ #include │ │ │ │ │ #include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ #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_/_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h> │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_u_t_i_l_i_t_y_._h_h> │ │ │ │ │ #include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_y_p_e_t_r_a_i_t_s_._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 │ │ │ │ │ - class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_<_ _C_h_i_l_d_r_e_n_ _> │ │ │ │ │ -  Base class for composite nodes based on variadic templates. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_<_ _C_h_i_l_d_r_e_n_ _>_:_:_C_h_i_l_d_<_ _k_ _> │ │ │ │ │ -  Access to the type and storage type of the i-th child. _M_o_r_e_._._. │ │ │ │ │ +class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_<_ _T_ _> │ │ │ │ │ +  Collect multiple instances of type T within a _d_u_n_e_-_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 │ │ │ │ │   │ │ │ │ │ =============================================================================== │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00026_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: compositenode.hh Source File │ │ │ │ +dune-typetree: dynamicpowernode.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,268 +74,221 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ -
    compositenode.hh
    │ │ │ │ +
    dynamicpowernode.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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_COMPOSITENODE_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_COMPOSITENODE_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_DYNAMICPOWERNODE_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_DYNAMICPOWERNODE_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <tuple>
    │ │ │ │ -
    10#include <memory>
    │ │ │ │ -
    11#include <type_traits>
    │ │ │ │ -
    12
    │ │ │ │ -
    13#include <dune/typetree/nodetags.hh>
    │ │ │ │ -
    14#include <dune/typetree/childextraction.hh>
    │ │ │ │ -
    15#include <dune/typetree/typetraits.hh>
    │ │ │ │ +
    9#include <cassert>
    │ │ │ │ +
    10#include <vector>
    │ │ │ │ +
    11#include <memory>
    │ │ │ │ +
    12#include <type_traits>
    │ │ │ │ +
    13
    │ │ │ │ +
    14#include <dune/common/typetraits.hh>
    │ │ │ │ +
    15#include <dune/common/std/type_traits.hh>
    │ │ │ │
    16
    │ │ │ │ -
    17namespace Dune {
    │ │ │ │ -
    18 namespace TypeTree {
    │ │ │ │ -
    19
    │ │ │ │ -
    26 template<typename... Children>
    │ │ │ │ -
    │ │ │ │ -
    27 class CompositeNode
    │ │ │ │ -
    28 {
    │ │ │ │ -
    29
    │ │ │ │ -
    30 public:
    │ │ │ │ -
    31
    │ │ │ │ -
    33 typedef CompositeNodeTag NodeTag;
    │ │ │ │ -
    34
    │ │ │ │ -
    36 typedef std::tuple<std::shared_ptr<Children>... > NodeStorage;
    │ │ │ │ -
    37
    │ │ │ │ -
    39 typedef std::tuple<Children...> ChildTypes;
    │ │ │ │ -
    40
    │ │ │ │ -
    42 static const bool isLeaf = false;
    │ │ │ │ -
    43
    │ │ │ │ -
    45 static const bool isPower = false;
    │ │ │ │ -
    46
    │ │ │ │ -
    48 static const bool isComposite = true;
    │ │ │ │ -
    49
    │ │ │ │ -
    │ │ │ │ -
    50 static constexpr auto degree ()
    │ │ │ │ -
    51 {
    │ │ │ │ -
    52 return std::integral_constant<std::size_t,sizeof...(Children)>{};
    │ │ │ │ -
    53 }
    │ │ │ │ -
    │ │ │ │ -
    54
    │ │ │ │ -
    56 template<std::size_t k>
    │ │ │ │ -
    │ │ │ │ -
    57 struct Child {
    │ │ │ │ -
    58
    │ │ │ │ -
    59 static_assert((k < degree()), "child index out of range");
    │ │ │ │ -
    60
    │ │ │ │ -
    62 typedef typename std::tuple_element<k,ChildTypes>::type Type;
    │ │ │ │ -
    63
    │ │ │ │ -
    65 typedef typename std::tuple_element<k,ChildTypes>::type type;
    │ │ │ │ -
    66 };
    │ │ │ │ -
    │ │ │ │ -
    67
    │ │ │ │ -
    70
    │ │ │ │ +
    17#include <dune/typetree/nodetags.hh>
    │ │ │ │ +
    18#include <dune/typetree/utility.hh>
    │ │ │ │ +
    19#include <dune/typetree/typetraits.hh>
    │ │ │ │ +
    20
    │ │ │ │ +
    21namespace Dune {
    │ │ │ │ +
    22 namespace TypeTree {
    │ │ │ │ +
    23
    │ │ │ │ +
    33 template<typename T>
    │ │ │ │ +
    │ │ │ │ +
    34 class DynamicPowerNode
    │ │ │ │ +
    35 {
    │ │ │ │ +
    36
    │ │ │ │ +
    37 public:
    │ │ │ │ +
    38
    │ │ │ │ +
    40 static const bool isLeaf = false;
    │ │ │ │ +
    41
    │ │ │ │ +
    43 static const bool isPower = true;
    │ │ │ │ +
    44
    │ │ │ │ +
    46 static const bool isComposite = false;
    │ │ │ │ +
    47
    │ │ │ │ +
    │ │ │ │ +
    49 std::size_t degree() const
    │ │ │ │ +
    50 {
    │ │ │ │ +
    51 return _children.size();
    │ │ │ │ +
    52 }
    │ │ │ │ +
    │ │ │ │ +
    53
    │ │ │ │ +
    55 typedef DynamicPowerNodeTag NodeTag;
    │ │ │ │ +
    56
    │ │ │ │ +
    58 typedef T ChildType;
    │ │ │ │ +
    59
    │ │ │ │ +
    61 typedef std::shared_ptr<T> ChildStorageType;
    │ │ │ │ +
    62
    │ │ │ │ +
    64 typedef std::shared_ptr<const T> ChildConstStorageType;
    │ │ │ │ +
    65
    │ │ │ │ +
    67 typedef std::vector<ChildStorageType> NodeStorage;
    │ │ │ │ +
    68
    │ │ │ │ +
    69
    │ │ │ │
    72
    │ │ │ │ -
    75 template<std::size_t k>
    │ │ │ │ -
    │ │ │ │ -
    76 typename Child<k>::Type& child (index_constant<k> = {})
    │ │ │ │ -
    77 {
    │ │ │ │ -
    78 return *std::get<k>(_children);
    │ │ │ │ -
    79 }
    │ │ │ │ +
    74
    │ │ │ │ +
    │ │ │ │ +
    77 ChildType& child (std::size_t i)
    │ │ │ │ +
    78 {
    │ │ │ │ +
    79 assert(i < degree() && "child index out of range");
    │ │ │ │ +
    80 return *_children[i];
    │ │ │ │ +
    81 }
    │ │ │ │
    │ │ │ │ -
    80
    │ │ │ │
    82
    │ │ │ │ -
    85 template<std::size_t k>
    │ │ │ │ -
    │ │ │ │ -
    86 const typename Child<k>::Type& child (index_constant<k> = {}) const
    │ │ │ │ -
    87 {
    │ │ │ │ -
    88 return *std::get<k>(_children);
    │ │ │ │ -
    89 }
    │ │ │ │ +
    84
    │ │ │ │ +
    │ │ │ │ +
    87 const ChildType& child (std::size_t i) const
    │ │ │ │ +
    88 {
    │ │ │ │ +
    89 assert(i < degree() && "child index out of range");
    │ │ │ │ +
    90 return *_children[i];
    │ │ │ │ +
    91 }
    │ │ │ │
    │ │ │ │ -
    90
    │ │ │ │
    92
    │ │ │ │ -
    95 template<std::size_t k>
    │ │ │ │ -
    │ │ │ │ -
    96 std::shared_ptr<typename Child<k>::Type> childStorage (index_constant<k> = {})
    │ │ │ │ -
    97 {
    │ │ │ │ -
    98 return std::get<k>(_children);
    │ │ │ │ -
    99 }
    │ │ │ │ +
    94
    │ │ │ │ +
    │ │ │ │ +
    97 ChildStorageType childStorage (std::size_t i)
    │ │ │ │ +
    98 {
    │ │ │ │ +
    99 assert(i < degree() && "child index out of range");
    │ │ │ │ +
    100 return _children[i];
    │ │ │ │ +
    101 }
    │ │ │ │
    │ │ │ │ -
    100
    │ │ │ │
    102
    │ │ │ │ -
    105 template<std::size_t k>
    │ │ │ │ -
    │ │ │ │ -
    106 std::shared_ptr<const typename Child<k>::Type> childStorage (index_constant<k> = {}) const
    │ │ │ │ -
    107 {
    │ │ │ │ -
    108 return std::get<k>(_children);
    │ │ │ │ -
    109 }
    │ │ │ │ -
    │ │ │ │ -
    110
    │ │ │ │ -
    112 template<std::size_t k>
    │ │ │ │ -
    │ │ │ │ -
    113 void setChild (typename Child<k>::Type& child, index_constant<k> = {})
    │ │ │ │ -
    114 {
    │ │ │ │ -
    115 std::get<k>(_children) = stackobject_to_shared_ptr(child);
    │ │ │ │ -
    116 }
    │ │ │ │ -
    │ │ │ │ -
    117
    │ │ │ │ -
    119 template<std::size_t k>
    │ │ │ │ -
    │ │ │ │ -
    120 void setChild (typename Child<k>::Type&& child, index_constant<k> = {})
    │ │ │ │ -
    121 {
    │ │ │ │ -
    122 std::get<k>(_children) = convert_arg(std::move(child));
    │ │ │ │ -
    123 }
    │ │ │ │ -
    │ │ │ │ -
    124
    │ │ │ │ -
    126 template<std::size_t k>
    │ │ │ │ -
    │ │ │ │ -
    127 void setChild (std::shared_ptr<typename Child<k>::Type> child, index_constant<k> = {})
    │ │ │ │ -
    128 {
    │ │ │ │ -
    129 std::get<k>(_children) = std::move(child);
    │ │ │ │ -
    130 }
    │ │ │ │ -
    │ │ │ │ -
    131
    │ │ │ │ -
    │ │ │ │ -
    132 const NodeStorage& nodeStorage () const
    │ │ │ │ -
    133 {
    │ │ │ │ -
    134 return _children;
    │ │ │ │ +
    104
    │ │ │ │ +
    │ │ │ │ +
    110 ChildConstStorageType childStorage (std::size_t i) const
    │ │ │ │ +
    111 {
    │ │ │ │ +
    112 assert(i < degree() && "child index out of range");
    │ │ │ │ +
    113 return _children[i];
    │ │ │ │ +
    114 }
    │ │ │ │ +
    │ │ │ │ +
    115
    │ │ │ │ +
    │ │ │ │ +
    117 void setChild (std::size_t i, ChildType& t)
    │ │ │ │ +
    118 {
    │ │ │ │ +
    119 assert(i < degree() && "child index out of range");
    │ │ │ │ +
    120 _children[i] = stackobject_to_shared_ptr(t);
    │ │ │ │ +
    121 }
    │ │ │ │ +
    │ │ │ │ +
    122
    │ │ │ │ +
    │ │ │ │ +
    124 void setChild (std::size_t i, ChildType&& t)
    │ │ │ │ +
    125 {
    │ │ │ │ +
    126 assert(i < degree() && "child index out of range");
    │ │ │ │ +
    127 _children[i] = convert_arg(std::move(t));
    │ │ │ │ +
    128 }
    │ │ │ │ +
    │ │ │ │ +
    129
    │ │ │ │ +
    │ │ │ │ +
    131 void setChild (std::size_t i, ChildStorageType st)
    │ │ │ │ +
    132 {
    │ │ │ │ +
    133 assert(i < degree() && "child index out of range");
    │ │ │ │ +
    134 _children[i] = std::move(st);
    │ │ │ │
    135 }
    │ │ │ │
    │ │ │ │
    136
    │ │ │ │ -
    138
    │ │ │ │ +
    │ │ │ │ +
    137 const NodeStorage& nodeStorage () const
    │ │ │ │ +
    138 {
    │ │ │ │ +
    139 return _children;
    │ │ │ │ +
    140 }
    │ │ │ │ +
    │ │ │ │
    141
    │ │ │ │ -
    142 // The following two methods require a little bit of SFINAE trickery to work correctly:
    │ │ │ │ -
    143 // We have to make sure that they don't shadow the methods for direct child access because
    │ │ │ │ -
    144 // those get called by the generic child() machinery. If that machinery picks up the methods
    │ │ │ │ -
    145 // defined below, we have an infinite recursion.
    │ │ │ │ -
    146 // So the methods make sure that either
    │ │ │ │ -
    147 //
    │ │ │ │ -
    148 // * there are more than one argument. In that case, we got multiple indices and can forward
    │ │ │ │ -
    149 // to the general machine.
    │ │ │ │ -
    150 //
    │ │ │ │ -
    151 // * the first argument is not a valid flat index, i.e. either a std::size_t or an index_constant.
    │ │ │ │ -
    152 // The argument thus has to be some kind of TreePath instance that we can also pass to the
    │ │ │ │ -
    153 // generic machine.
    │ │ │ │ -
    154 //
    │ │ │ │ -
    155 // The above SFINAE logic works, but there is still a problem with the return type deduction.
    │ │ │ │ -
    156 // We have to do a lazy lookup of the return type after SFINAE has succeeded, otherwise the return
    │ │ │ │ -
    157 // type deduction will trigger the infinite recursion.
    │ │ │ │ -
    158
    │ │ │ │ -
    160
    │ │ │ │ -
    164#ifdef DOXYGEN
    │ │ │ │ -
    165 template<typename... Indices>
    │ │ │ │ -
    │ │ │ │ -
    166 ImplementationDefined& child (Indices... indices)
    │ │ │ │ -
    167#else
    │ │ │ │ -
    168 template<typename I0, typename... I,
    │ │ │ │ -
    169 std::enable_if_t<(sizeof...(I) > 0) || IsTreePath<I0>::value, int > = 0>
    │ │ │ │ -
    170 decltype(auto) child (I0 i0, I... i)
    │ │ │ │ -
    171#endif
    │ │ │ │ -
    172 {
    │ │ │ │ -
    173 static_assert(sizeof...(I) > 0 || impl::_non_empty_tree_path(I0{}),
    │ │ │ │ -
    174 "You cannot use the member function child() with an empty TreePath, use the freestanding version child(node,treePath) instead."
    │ │ │ │ -
    175 );
    │ │ │ │ -
    176 return Dune::TypeTree::child(*this,i0,i...);
    │ │ │ │ -
    177 }
    │ │ │ │ +
    143
    │ │ │ │ +
    146
    │ │ │ │ +
    147 protected:
    │ │ │ │ +
    148
    │ │ │ │ +
    151 DynamicPowerNode () = delete;
    │ │ │ │ +
    152
    │ │ │ │ +
    154
    │ │ │ │ +
    │ │ │ │ +
    162 explicit DynamicPowerNode (std::size_t size)
    │ │ │ │ +
    163 : _children(size)
    │ │ │ │ +
    164 {}
    │ │ │ │ +
    │ │ │ │ +
    165
    │ │ │ │ +
    │ │ │ │ +
    167 explicit DynamicPowerNode (NodeStorage children)
    │ │ │ │ +
    168 : _children(std::move(children))
    │ │ │ │ +
    169 {}
    │ │ │ │ +
    │ │ │ │ +
    170
    │ │ │ │ +
    171#ifdef DOXYGEN
    │ │ │ │ +
    172
    │ │ │ │ +
    │ │ │ │ +
    174 DynamicPowerNode (T& t1, T& t2, ...)
    │ │ │ │ +
    175 {}
    │ │ │ │
    │ │ │ │ +
    176
    │ │ │ │ +
    177#else
    │ │ │ │
    178
    │ │ │ │ -
    180
    │ │ │ │ -
    184#ifdef DOXYGEN
    │ │ │ │ -
    185 template<typename... Indices>
    │ │ │ │ -
    │ │ │ │ -
    186 const ImplementationDefined& child (Indices... indices)
    │ │ │ │ -
    187#else
    │ │ │ │ -
    188 template<typename I0, typename... I,
    │ │ │ │ -
    189 std::enable_if_t<(sizeof...(I) > 0) || IsTreePath<I0>::value, int > = 0>
    │ │ │ │ -
    190 decltype(auto) child (I0 i0, I... i) const
    │ │ │ │ -
    191#endif
    │ │ │ │ -
    192 {
    │ │ │ │ -
    193 static_assert(sizeof...(I) > 0 || impl::_non_empty_tree_path(I0{}),
    │ │ │ │ -
    194 "You cannot use the member function child() with an empty TreePath, use the freestanding version child(node,treePath) instead."
    │ │ │ │ -
    195 );
    │ │ │ │ -
    196 return Dune::TypeTree::child(*this,i0,i...);
    │ │ │ │ -
    197 }
    │ │ │ │ +
    179 template<typename... Children,
    │ │ │ │ +
    180 std::enable_if_t<(std::is_same_v<ChildType, std::decay_t<Children>> &&...), bool> = true>
    │ │ │ │ +
    181 DynamicPowerNode (Children&&... children)
    │ │ │ │ +
    182 {
    │ │ │ │ +
    183 _children = NodeStorage{convert_arg(std::forward<Children>(children))...};
    │ │ │ │ +
    184 }
    │ │ │ │ +
    185
    │ │ │ │ +
    186 template<typename... Children,
    │ │ │ │ +
    187 std::enable_if_t<(std::is_same_v<ChildType, std::decay_t<Children>> &&...), bool> = true>
    │ │ │ │ +
    188 DynamicPowerNode (std::shared_ptr<Children>... children)
    │ │ │ │ +
    189 {
    │ │ │ │ +
    190 _children = NodeStorage{std::move(children)...};
    │ │ │ │ +
    191 }
    │ │ │ │ +
    192
    │ │ │ │ +
    193#endif // DOXYGEN
    │ │ │ │ +
    194
    │ │ │ │ +
    196
    │ │ │ │ +
    197 private:
    │ │ │ │ +
    198 NodeStorage _children;
    │ │ │ │ +
    199 };
    │ │ │ │
    │ │ │ │ -
    198
    │ │ │ │
    200
    │ │ │ │ -
    201 protected:
    │ │ │ │
    202
    │ │ │ │ +
    203 } // namespace TypeTree
    │ │ │ │ +
    204} //namespace Dune
    │ │ │ │
    205
    │ │ │ │ -
    207
    │ │ │ │ -
    │ │ │ │ -
    214 CompositeNode ()
    │ │ │ │ -
    215 {}
    │ │ │ │ -
    │ │ │ │ -
    216
    │ │ │ │ -
    218 template<typename... Args, typename = typename std::enable_if<(sizeof...(Args) == degree())>::type>
    │ │ │ │ -
    │ │ │ │ -
    219 CompositeNode (Args&&... args)
    │ │ │ │ -
    220 : _children(convert_arg(std::forward<Args>(args))...)
    │ │ │ │ -
    221 {}
    │ │ │ │ -
    │ │ │ │ -
    222
    │ │ │ │ -
    │ │ │ │ -
    224 CompositeNode (std::shared_ptr<Children>... children)
    │ │ │ │ -
    225 : _children(std::move(children)...)
    │ │ │ │ -
    226 {}
    │ │ │ │ -
    │ │ │ │ -
    227
    │ │ │ │ -
    │ │ │ │ -
    229 CompositeNode (const NodeStorage& children)
    │ │ │ │ -
    230 : _children(children)
    │ │ │ │ -
    231 {}
    │ │ │ │ -
    │ │ │ │ -
    232
    │ │ │ │ -
    234
    │ │ │ │ -
    235 private:
    │ │ │ │ -
    236 NodeStorage _children;
    │ │ │ │ -
    237 };
    │ │ │ │ -
    │ │ │ │ -
    238
    │ │ │ │ -
    240
    │ │ │ │ -
    241 } // namespace TypeTree
    │ │ │ │ -
    242} //namespace Dune
    │ │ │ │ -
    243
    │ │ │ │ -
    244#endif // DUNE_TYPETREE_COMPOSITENODE_HH
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::child
    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
    │ │ │ │ +
    206#endif // DUNE_TYPETREE_DYNAMICPOWERNODE_HH
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::CompositeNode
    Base class for composite nodes based on variadic templates.
    Definition compositenode.hh:28
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::isLeaf
    static const bool isLeaf
    Mark this class as non leaf in the dune-typetree.
    Definition compositenode.hh:42
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::child
    ImplementationDefined & child(Indices... indices)
    Returns the child given by the list of indices.
    Definition compositenode.hh:166
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::isComposite
    static const bool isComposite
    Mark this class as a composite in the dune-typetree.
    Definition compositenode.hh:48
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::CompositeNode
    CompositeNode()
    Default constructor.
    Definition compositenode.hh:214
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::NodeTag
    CompositeNodeTag NodeTag
    The type tag that describes a CompositeNode.
    Definition compositenode.hh:33
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::setChild
    void setChild(typename Child< k >::Type &child, index_constant< k >={})
    Sets the k-th child to the passed-in value.
    Definition compositenode.hh:113
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::setChild
    void setChild(typename Child< k >::Type &&child, index_constant< k >={})
    Store the passed value in k-th child.
    Definition compositenode.hh:120
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::degree
    static constexpr auto degree()
    Definition compositenode.hh:50
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::nodeStorage
    const NodeStorage & nodeStorage() const
    Definition compositenode.hh:132
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::CompositeNode
    CompositeNode(std::shared_ptr< Children >... children)
    Initialize the CompositeNode with copies of the passed in Storage objects.
    Definition compositenode.hh:224
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::childStorage
    std::shared_ptr< typename Child< k >::Type > childStorage(index_constant< k >={})
    Returns the storage of the k-th child.
    Definition compositenode.hh:96
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::ChildTypes
    std::tuple< Children... > ChildTypes
    A tuple storing the types of all children.
    Definition compositenode.hh:39
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::setChild
    void setChild(std::shared_ptr< typename Child< k >::Type > child, index_constant< k >={})
    Sets the storage of the k-th child to the passed-in value.
    Definition compositenode.hh:127
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::child
    const ImplementationDefined & child(Indices... indices)
    Returns the child given by the list of indices.
    Definition compositenode.hh:186
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::isPower
    static const bool isPower
    Mark this class as a non power in the dune-typetree.
    Definition compositenode.hh:45
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::childStorage
    std::shared_ptr< const typename Child< k >::Type > childStorage(index_constant< k >={}) const
    Returns the storage of the k-th child (const version).
    Definition compositenode.hh:106
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::child
    Child< k >::Type & child(index_constant< k >={})
    Returns the k-th child.
    Definition compositenode.hh:76
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::CompositeNode
    CompositeNode(const NodeStorage &children)
    Initialize the CompositeNode with a copy of the passed-in storage type.
    Definition compositenode.hh:229
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::NodeStorage
    std::tuple< std::shared_ptr< Children >... > NodeStorage
    The type used for storing the children.
    Definition compositenode.hh:36
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::child
    const Child< k >::Type & child(index_constant< k >={}) const
    Returns the k-th child (const version).
    Definition compositenode.hh:86
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::Child
    Access to the type and storage type of the i-th child.
    Definition compositenode.hh:57
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::Child::Type
    std::tuple_element< k, ChildTypes >::type Type
    The type of the child.
    Definition compositenode.hh:62
    │ │ │ │ -
    Dune::TypeTree::CompositeNode::Child::type
    std::tuple_element< k, ChildTypes >::type type
    The type of the child.
    Definition compositenode.hh:65
    │ │ │ │ -
    Dune::TypeTree::CompositeNodeTag
    Tag designating a composite node.
    Definition nodetags.hh:27
    │ │ │ │ -
    Dune::TypeTree::IsTreePath
    Check if type represents a tree path.
    Definition typetraits.hh:184
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode
    Collect multiple instances of type T within a dune-typetree.
    Definition dynamicpowernode.hh:35
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::isPower
    static const bool isPower
    Mark this class as a power in the dune-typetree.
    Definition dynamicpowernode.hh:43
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::NodeStorage
    std::vector< ChildStorageType > NodeStorage
    The type used for storing the children.
    Definition dynamicpowernode.hh:67
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::nodeStorage
    const NodeStorage & nodeStorage() const
    Definition dynamicpowernode.hh:137
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::childStorage
    ChildConstStorageType childStorage(std::size_t i) const
    Returns the storage of the i-th child (const version).
    Definition dynamicpowernode.hh:110
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::child
    const ChildType & child(std::size_t i) const
    Returns the i-th child (const version).
    Definition dynamicpowernode.hh:87
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::ChildStorageType
    std::shared_ptr< T > ChildStorageType
    The storage type of each child.
    Definition dynamicpowernode.hh:61
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::DynamicPowerNode
    DynamicPowerNode(T &t1, T &t2,...)
    Initialize all children with the passed-in objects.
    Definition dynamicpowernode.hh:174
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::ChildConstStorageType
    std::shared_ptr< const T > ChildConstStorageType
    The const version of the storage type of each child.
    Definition dynamicpowernode.hh:64
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::DynamicPowerNode
    DynamicPowerNode(NodeStorage children)
    Initialize the DynamicPowerNode with a copy of the passed-in storage type.
    Definition dynamicpowernode.hh:167
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::NodeTag
    DynamicPowerNodeTag NodeTag
    The type tag that describes the node.
    Definition dynamicpowernode.hh:55
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::ChildType
    T ChildType
    The type of each child.
    Definition dynamicpowernode.hh:58
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::setChild
    void setChild(std::size_t i, ChildType &t)
    Sets the i-th child to the passed-in value.
    Definition dynamicpowernode.hh:117
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::setChild
    void setChild(std::size_t i, ChildStorageType st)
    Sets the stored value representing the i-th child to the passed-in value.
    Definition dynamicpowernode.hh:131
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::DynamicPowerNode
    DynamicPowerNode(std::size_t size)
    Construct a node with the given number of children.
    Definition dynamicpowernode.hh:162
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::isComposite
    static const bool isComposite
    Mark this class as a non composite in the dune-typetree.
    Definition dynamicpowernode.hh:46
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::setChild
    void setChild(std::size_t i, ChildType &&t)
    Store the passed value in i-th child.
    Definition dynamicpowernode.hh:124
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::child
    ChildType & child(std::size_t i)
    Returns the i-th child.
    Definition dynamicpowernode.hh:77
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::degree
    std::size_t degree() const
    The number of children.
    Definition dynamicpowernode.hh:49
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::childStorage
    ChildStorageType childStorage(std::size_t i)
    Returns the storage of the i-th child.
    Definition dynamicpowernode.hh:97
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNode::isLeaf
    static const bool isLeaf
    Mark this class as non leaf in the dune-typetree.
    Definition dynamicpowernode.hh:40
    │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::DynamicPowerNodeTag
    Tag designating a power node with runtime degree.
    Definition nodetags.hh:24
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,323 +1,257 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -compositenode.hh │ │ │ │ │ +dynamicpowernode.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_COMPOSITENODE_HH │ │ │ │ │ -7#define DUNE_TYPETREE_COMPOSITENODE_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_DYNAMICPOWERNODE_HH │ │ │ │ │ +7#define DUNE_TYPETREE_DYNAMICPOWERNODE_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include │ │ │ │ │ -10#include │ │ │ │ │ -11#include │ │ │ │ │ -12 │ │ │ │ │ -13#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ -14#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h> │ │ │ │ │ -15#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_y_p_e_t_r_a_i_t_s_._h_h> │ │ │ │ │ +9#include │ │ │ │ │ +10#include │ │ │ │ │ +11#include │ │ │ │ │ +12#include │ │ │ │ │ +13 │ │ │ │ │ +14#include │ │ │ │ │ +15#include │ │ │ │ │ 16 │ │ │ │ │ -17namespace _D_u_n_e { │ │ │ │ │ -18 namespace TypeTree { │ │ │ │ │ -19 │ │ │ │ │ -26 template │ │ │ │ │ -_2_7 class _C_o_m_p_o_s_i_t_e_N_o_d_e │ │ │ │ │ -28 { │ │ │ │ │ -29 │ │ │ │ │ -30 public: │ │ │ │ │ -31 │ │ │ │ │ -_3_3 typedef _C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g _N_o_d_e_T_a_g; │ │ │ │ │ -34 │ │ │ │ │ -_3_6 typedef std::tuple... > _N_o_d_e_S_t_o_r_a_g_e; │ │ │ │ │ -37 │ │ │ │ │ -_3_9 typedef std::tuple _C_h_i_l_d_T_y_p_e_s; │ │ │ │ │ -40 │ │ │ │ │ -_4_2 static const bool _i_s_L_e_a_f = false; │ │ │ │ │ -43 │ │ │ │ │ -_4_5 static const bool _i_s_P_o_w_e_r = false; │ │ │ │ │ -46 │ │ │ │ │ -_4_8 static const bool _i_s_C_o_m_p_o_s_i_t_e = true; │ │ │ │ │ -49 │ │ │ │ │ -_5_0 static constexpr auto _d_e_g_r_e_e () │ │ │ │ │ -51 { │ │ │ │ │ -52 return std::integral_constant{}; │ │ │ │ │ -53 } │ │ │ │ │ -54 │ │ │ │ │ -56 template │ │ │ │ │ -_5_7 struct _C_h_i_l_d { │ │ │ │ │ -58 │ │ │ │ │ -59 static_assert((k < _d_e_g_r_e_e()), "child index out of range"); │ │ │ │ │ -60 │ │ │ │ │ -_6_2 typedef typename std::tuple_element::type _T_y_p_e; │ │ │ │ │ -63 │ │ │ │ │ -_6_5 typedef typename std::tuple_element::type _t_y_p_e; │ │ │ │ │ -66 }; │ │ │ │ │ -67 │ │ │ │ │ -70 │ │ │ │ │ +17#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ +18#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_u_t_i_l_i_t_y_._h_h> │ │ │ │ │ +19#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_y_p_e_t_r_a_i_t_s_._h_h> │ │ │ │ │ +20 │ │ │ │ │ +21namespace _D_u_n_e { │ │ │ │ │ +22 namespace TypeTree { │ │ │ │ │ +23 │ │ │ │ │ +33 template │ │ │ │ │ +_3_4 class _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e │ │ │ │ │ +35 { │ │ │ │ │ +36 │ │ │ │ │ +37 public: │ │ │ │ │ +38 │ │ │ │ │ +_4_0 static const bool _i_s_L_e_a_f = false; │ │ │ │ │ +41 │ │ │ │ │ +_4_3 static const bool _i_s_P_o_w_e_r = true; │ │ │ │ │ +44 │ │ │ │ │ +_4_6 static const bool _i_s_C_o_m_p_o_s_i_t_e = false; │ │ │ │ │ +47 │ │ │ │ │ +_4_9 std::size_t _d_e_g_r_e_e() const │ │ │ │ │ +50 { │ │ │ │ │ +51 return _children.size(); │ │ │ │ │ +52 } │ │ │ │ │ +53 │ │ │ │ │ +_5_5 typedef _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g _N_o_d_e_T_a_g; │ │ │ │ │ +56 │ │ │ │ │ +_5_8 typedef T _C_h_i_l_d_T_y_p_e; │ │ │ │ │ +59 │ │ │ │ │ +_6_1 typedef std::shared_ptr _C_h_i_l_d_S_t_o_r_a_g_e_T_y_p_e; │ │ │ │ │ +62 │ │ │ │ │ +_6_4 typedef std::shared_ptr _C_h_i_l_d_C_o_n_s_t_S_t_o_r_a_g_e_T_y_p_e; │ │ │ │ │ +65 │ │ │ │ │ +_6_7 typedef std::vector _N_o_d_e_S_t_o_r_a_g_e; │ │ │ │ │ +68 │ │ │ │ │ +69 │ │ │ │ │ 72 │ │ │ │ │ -75 template │ │ │ │ │ -_7_6 typename _C_h_i_l_d_<_k_>_:_:_T_y_p_e& _c_h_i_l_d (index_constant = {}) │ │ │ │ │ -77 { │ │ │ │ │ -78 return *std::get(_children); │ │ │ │ │ -79 } │ │ │ │ │ -80 │ │ │ │ │ +74 │ │ │ │ │ +_7_7 _C_h_i_l_d_T_y_p_e& _c_h_i_l_d (std::size_t i) │ │ │ │ │ +78 { │ │ │ │ │ +79 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ +80 return *_children[i]; │ │ │ │ │ +81 } │ │ │ │ │ 82 │ │ │ │ │ -85 template │ │ │ │ │ -_8_6 const typename _C_h_i_l_d_<_k_>_:_:_T_y_p_e& _c_h_i_l_d (index_constant = {}) const │ │ │ │ │ -87 { │ │ │ │ │ -88 return *std::get(_children); │ │ │ │ │ -89 } │ │ │ │ │ -90 │ │ │ │ │ +84 │ │ │ │ │ +_8_7 const _C_h_i_l_d_T_y_p_e& _c_h_i_l_d (std::size_t i) const │ │ │ │ │ +88 { │ │ │ │ │ +89 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ +90 return *_children[i]; │ │ │ │ │ +91 } │ │ │ │ │ 92 │ │ │ │ │ -95 template │ │ │ │ │ -_9_6 std::shared_ptr::Type> _c_h_i_l_d_S_t_o_r_a_g_e (index_constant = │ │ │ │ │ -{}) │ │ │ │ │ -97 { │ │ │ │ │ -98 return std::get(_children); │ │ │ │ │ -99 } │ │ │ │ │ -100 │ │ │ │ │ +94 │ │ │ │ │ +_9_7 _C_h_i_l_d_S_t_o_r_a_g_e_T_y_p_e _c_h_i_l_d_S_t_o_r_a_g_e (std::size_t i) │ │ │ │ │ +98 { │ │ │ │ │ +99 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ +100 return _children[i]; │ │ │ │ │ +101 } │ │ │ │ │ 102 │ │ │ │ │ -105 template │ │ │ │ │ -_1_0_6 std::shared_ptr::Type> _c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ -(index_constant = {}) const │ │ │ │ │ -107 { │ │ │ │ │ -108 return std::get(_children); │ │ │ │ │ -109 } │ │ │ │ │ -110 │ │ │ │ │ -112 template │ │ │ │ │ -_1_1_3 void _s_e_t_C_h_i_l_d (typename _C_h_i_l_d_<_k_>_:_:_T_y_p_e& _c_h_i_l_d, index_constant = {}) │ │ │ │ │ -114 { │ │ │ │ │ -115 std::get(_children) = stackobject_to_shared_ptr(_c_h_i_l_d); │ │ │ │ │ -116 } │ │ │ │ │ -117 │ │ │ │ │ -119 template │ │ │ │ │ -_1_2_0 void _s_e_t_C_h_i_l_d (typename _C_h_i_l_d_<_k_>_:_:_T_y_p_e&& _c_h_i_l_d, index_constant = {}) │ │ │ │ │ -121 { │ │ │ │ │ -122 std::get(_children) = convert_arg(std::move(_c_h_i_l_d)); │ │ │ │ │ -123 } │ │ │ │ │ -124 │ │ │ │ │ -126 template │ │ │ │ │ -_1_2_7 void _s_e_t_C_h_i_l_d (std::shared_ptr_:_:_T_y_p_e> _c_h_i_l_d, │ │ │ │ │ -index_constant = {}) │ │ │ │ │ -128 { │ │ │ │ │ -129 std::get(_children) = std::move(_c_h_i_l_d); │ │ │ │ │ -130 } │ │ │ │ │ -131 │ │ │ │ │ -_1_3_2 const _N_o_d_e_S_t_o_r_a_g_e& _n_o_d_e_S_t_o_r_a_g_e () const │ │ │ │ │ -133 { │ │ │ │ │ -134 return _children; │ │ │ │ │ +104 │ │ │ │ │ +_1_1_0 _C_h_i_l_d_C_o_n_s_t_S_t_o_r_a_g_e_T_y_p_e _c_h_i_l_d_S_t_o_r_a_g_e (std::size_t i) const │ │ │ │ │ +111 { │ │ │ │ │ +112 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ +113 return _children[i]; │ │ │ │ │ +114 } │ │ │ │ │ +115 │ │ │ │ │ +_1_1_7 void _s_e_t_C_h_i_l_d (std::size_t i, _C_h_i_l_d_T_y_p_e& t) │ │ │ │ │ +118 { │ │ │ │ │ +119 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ +120 _children[i] = stackobject_to_shared_ptr(t); │ │ │ │ │ +121 } │ │ │ │ │ +122 │ │ │ │ │ +_1_2_4 void _s_e_t_C_h_i_l_d (std::size_t i, _C_h_i_l_d_T_y_p_e&& t) │ │ │ │ │ +125 { │ │ │ │ │ +126 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ +127 _children[i] = convert_arg(std::move(t)); │ │ │ │ │ +128 } │ │ │ │ │ +129 │ │ │ │ │ +_1_3_1 void _s_e_t_C_h_i_l_d (std::size_t i, _C_h_i_l_d_S_t_o_r_a_g_e_T_y_p_e st) │ │ │ │ │ +132 { │ │ │ │ │ +133 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ +134 _children[i] = std::move(st); │ │ │ │ │ 135 } │ │ │ │ │ 136 │ │ │ │ │ -138 │ │ │ │ │ +_1_3_7 const _N_o_d_e_S_t_o_r_a_g_e& _n_o_d_e_S_t_o_r_a_g_e () const │ │ │ │ │ +138 { │ │ │ │ │ +139 return _children; │ │ │ │ │ +140 } │ │ │ │ │ 141 │ │ │ │ │ -142 // The following two methods require a little bit of SFINAE trickery to │ │ │ │ │ -work correctly: │ │ │ │ │ -143 // We have to make sure that they don't shadow the methods for direct child │ │ │ │ │ -access because │ │ │ │ │ -144 // those get called by the generic child() machinery. If that machinery │ │ │ │ │ -picks up the methods │ │ │ │ │ -145 // defined below, we have an infinite recursion. │ │ │ │ │ -146 // So the methods make sure that either │ │ │ │ │ -147 // │ │ │ │ │ -148 // * there are more than one argument. In that case, we got multiple │ │ │ │ │ -indices and can forward │ │ │ │ │ -149 // to the general machine. │ │ │ │ │ -150 // │ │ │ │ │ -151 // * the first argument is not a valid flat index, i.e. either a std:: │ │ │ │ │ -size_t or an index_constant. │ │ │ │ │ -152 // The argument thus has to be some kind of TreePath instance that we can │ │ │ │ │ -also pass to the │ │ │ │ │ -153 // generic machine. │ │ │ │ │ -154 // │ │ │ │ │ -155 // The above SFINAE logic works, but there is still a problem with the │ │ │ │ │ -return type deduction. │ │ │ │ │ -156 // We have to do a lazy lookup of the return type after SFINAE has │ │ │ │ │ -succeeded, otherwise the return │ │ │ │ │ -157 // type deduction will trigger the infinite recursion. │ │ │ │ │ -158 │ │ │ │ │ -160 │ │ │ │ │ -164#ifdef DOXYGEN │ │ │ │ │ -165 template │ │ │ │ │ -_1_6_6 ImplementationDefined& _c_h_i_l_d (Indices... indices) │ │ │ │ │ -167#else │ │ │ │ │ -168 template 0) || _I_s_T_r_e_e_P_a_t_h_<_I_0_>_:_:_v_a_l_u_e, int > = 0> │ │ │ │ │ -170 decltype(auto) _c_h_i_l_d (I0 i0, I... i) │ │ │ │ │ -171#endif │ │ │ │ │ -172 { │ │ │ │ │ -173 static_assert(sizeof...(I) > 0 || impl::_non_empty_tree_path(I0{}), │ │ │ │ │ -174 "You cannot use the member function child() with an empty TreePath, use the │ │ │ │ │ -freestanding version child(node,treePath) instead." │ │ │ │ │ -175 ); │ │ │ │ │ -176 return _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_c_h_i_l_d(*this,i0,i...); │ │ │ │ │ -177 } │ │ │ │ │ +143 │ │ │ │ │ +146 │ │ │ │ │ +147 protected: │ │ │ │ │ +148 │ │ │ │ │ +_1_5_1 _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e () = delete; │ │ │ │ │ +152 │ │ │ │ │ +154 │ │ │ │ │ +_1_6_2 explicit _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e (std::size_t size) │ │ │ │ │ +163 : _children(size) │ │ │ │ │ +164 {} │ │ │ │ │ +165 │ │ │ │ │ +_1_6_7 explicit _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e (_N_o_d_e_S_t_o_r_a_g_e children) │ │ │ │ │ +168 : _children(std::move(children)) │ │ │ │ │ +169 {} │ │ │ │ │ +170 │ │ │ │ │ +171#ifdef DOXYGEN │ │ │ │ │ +172 │ │ │ │ │ +_1_7_4 _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e (T& t1, T& t2, ...) │ │ │ │ │ +175 {} │ │ │ │ │ +176 │ │ │ │ │ +177#else │ │ │ │ │ 178 │ │ │ │ │ -180 │ │ │ │ │ -184#ifdef DOXYGEN │ │ │ │ │ -185 template │ │ │ │ │ -_1_8_6 const ImplementationDefined& _c_h_i_l_d (Indices... indices) │ │ │ │ │ -187#else │ │ │ │ │ -188 template 0) || _I_s_T_r_e_e_P_a_t_h_<_I_0_>_:_:_v_a_l_u_e, int > = 0> │ │ │ │ │ -190 decltype(auto) _c_h_i_l_d (I0 i0, I... i) const │ │ │ │ │ -191#endif │ │ │ │ │ -192 { │ │ │ │ │ -193 static_assert(sizeof...(I) > 0 || impl::_non_empty_tree_path(I0{}), │ │ │ │ │ -194 "You cannot use the member function child() with an empty TreePath, use the │ │ │ │ │ -freestanding version child(node,treePath) instead." │ │ │ │ │ -195 ); │ │ │ │ │ -196 return _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_c_h_i_l_d(*this,i0,i...); │ │ │ │ │ -197 } │ │ │ │ │ -198 │ │ │ │ │ +179 template> &&...), │ │ │ │ │ +bool> = true> │ │ │ │ │ +181 _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e (Children&&... children) │ │ │ │ │ +182 { │ │ │ │ │ +183 _children = _N_o_d_e_S_t_o_r_a_g_e{convert_arg(std::forward(children))...}; │ │ │ │ │ +184 } │ │ │ │ │ +185 │ │ │ │ │ +186 template> &&...), │ │ │ │ │ +bool> = true> │ │ │ │ │ +188 _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e (std::shared_ptr... children) │ │ │ │ │ +189 { │ │ │ │ │ +190 _children = _N_o_d_e_S_t_o_r_a_g_e{std::move(children)...}; │ │ │ │ │ +191 } │ │ │ │ │ +192 │ │ │ │ │ +193#endif // DOXYGEN │ │ │ │ │ +194 │ │ │ │ │ +196 │ │ │ │ │ +197 private: │ │ │ │ │ +198 _N_o_d_e_S_t_o_r_a_g_e _children; │ │ │ │ │ +199 }; │ │ │ │ │ 200 │ │ │ │ │ -201 protected: │ │ │ │ │ 202 │ │ │ │ │ +203 } // namespace TypeTree │ │ │ │ │ +204} //namespace Dune │ │ │ │ │ 205 │ │ │ │ │ -207 │ │ │ │ │ -_2_1_4 _C_o_m_p_o_s_i_t_e_N_o_d_e () │ │ │ │ │ -215 {} │ │ │ │ │ -216 │ │ │ │ │ -218 template::type> │ │ │ │ │ -_2_1_9 _C_o_m_p_o_s_i_t_e_N_o_d_e (Args&&... args) │ │ │ │ │ -220 : _children(convert_arg(std::forward(args))...) │ │ │ │ │ -221 {} │ │ │ │ │ -222 │ │ │ │ │ -_2_2_4 _C_o_m_p_o_s_i_t_e_N_o_d_e (std::shared_ptr... children) │ │ │ │ │ -225 : _children(std::move(children)...) │ │ │ │ │ -226 {} │ │ │ │ │ -227 │ │ │ │ │ -_2_2_9 _C_o_m_p_o_s_i_t_e_N_o_d_e (const _N_o_d_e_S_t_o_r_a_g_e& children) │ │ │ │ │ -230 : _children(children) │ │ │ │ │ -231 {} │ │ │ │ │ -232 │ │ │ │ │ -234 │ │ │ │ │ -235 private: │ │ │ │ │ -236 _N_o_d_e_S_t_o_r_a_g_e _children; │ │ │ │ │ -237 }; │ │ │ │ │ -238 │ │ │ │ │ -240 │ │ │ │ │ -241 } // namespace TypeTree │ │ │ │ │ -242} //namespace Dune │ │ │ │ │ -243 │ │ │ │ │ -244#endif // DUNE_TYPETREE_COMPOSITENODE_HH │ │ │ │ │ +206#endif // DUNE_TYPETREE_DYNAMICPOWERNODE_HH │ │ │ │ │ _t_y_p_e_t_r_a_i_t_s_._h_h │ │ │ │ │ -_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h │ │ │ │ │ +_u_t_i_l_i_t_y_._h_h │ │ │ │ │ _n_o_d_e_t_a_g_s_._h_h │ │ │ │ │ -_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 │ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e │ │ │ │ │ -Base class for composite nodes based on variadic templates. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:28 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_i_s_L_e_a_f │ │ │ │ │ -static const bool isLeaf │ │ │ │ │ -Mark this class as non leaf in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:42 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ -ImplementationDefined & child(Indices... indices) │ │ │ │ │ -Returns the child given by the list of indices. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:166 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_i_s_C_o_m_p_o_s_i_t_e │ │ │ │ │ -static const bool isComposite │ │ │ │ │ -Mark this class as a composite in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:48 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e │ │ │ │ │ -CompositeNode() │ │ │ │ │ -Default constructor. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:214 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_N_o_d_e_T_a_g │ │ │ │ │ -CompositeNodeTag NodeTag │ │ │ │ │ -The type tag that describes a CompositeNode. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:33 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ -void setChild(typename Child< k >::Type &child, index_constant< k >={}) │ │ │ │ │ -Sets the k-th child to the passed-in value. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:113 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ -void setChild(typename Child< k >::Type &&child, index_constant< k >={}) │ │ │ │ │ -Store the passed value in k-th child. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:120 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_d_e_g_r_e_e │ │ │ │ │ -static constexpr auto degree() │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:50 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_n_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ -const NodeStorage & nodeStorage() const │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:132 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e │ │ │ │ │ -CompositeNode(std::shared_ptr< Children >... children) │ │ │ │ │ -Initialize the CompositeNode with copies of the passed in Storage objects. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:224 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ -std::shared_ptr< typename Child< k >::Type > childStorage(index_constant< k >= │ │ │ │ │ -{}) │ │ │ │ │ -Returns the storage of the k-th child. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:96 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_h_i_l_d_T_y_p_e_s │ │ │ │ │ -std::tuple< Children... > ChildTypes │ │ │ │ │ -A tuple storing the types of all children. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:39 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ -void setChild(std::shared_ptr< typename Child< k >::Type > child, │ │ │ │ │ -index_constant< k >={}) │ │ │ │ │ -Sets the storage of the k-th child to the passed-in value. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:127 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ -const ImplementationDefined & child(Indices... indices) │ │ │ │ │ -Returns the child given by the list of indices. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:186 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_i_s_P_o_w_e_r │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e │ │ │ │ │ +Collect multiple instances of type T within a dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:35 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_i_s_P_o_w_e_r │ │ │ │ │ static const bool isPower │ │ │ │ │ -Mark this class as a non power in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:45 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ -std::shared_ptr< const typename Child< k >::Type > childStorage(index_constant< │ │ │ │ │ -k >={}) const │ │ │ │ │ -Returns the storage of the k-th child (const version). │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:106 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ -Child< k >::Type & child(index_constant< k >={}) │ │ │ │ │ -Returns the k-th child. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:76 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e │ │ │ │ │ -CompositeNode(const NodeStorage &children) │ │ │ │ │ -Initialize the CompositeNode with a copy of the passed-in storage type. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:229 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ -std::tuple< std::shared_ptr< Children >... > NodeStorage │ │ │ │ │ +Mark this class as a power in the dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:43 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ +std::vector< ChildStorageType > NodeStorage │ │ │ │ │ The type used for storing the children. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:36 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ -const Child< k >::Type & child(index_constant< k >={}) const │ │ │ │ │ -Returns the k-th child (const version). │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:86 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_h_i_l_d │ │ │ │ │ -Access to the type and storage type of the i-th child. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:57 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_h_i_l_d_:_:_T_y_p_e │ │ │ │ │ -std::tuple_element< k, ChildTypes >::type Type │ │ │ │ │ -The type of the child. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:62 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_h_i_l_d_:_:_t_y_p_e │ │ │ │ │ -std::tuple_element< k, ChildTypes >::type type │ │ │ │ │ -The type of the child. │ │ │ │ │ -DDeeffiinniittiioonn compositenode.hh:65 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g │ │ │ │ │ -Tag designating a composite node. │ │ │ │ │ -DDeeffiinniittiioonn nodetags.hh:27 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_I_s_T_r_e_e_P_a_t_h │ │ │ │ │ -Check if type represents a tree path. │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:184 │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:67 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_n_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ +const NodeStorage & nodeStorage() const │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:137 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ +ChildConstStorageType childStorage(std::size_t i) const │ │ │ │ │ +Returns the storage of the i-th child (const version). │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:110 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ +const ChildType & child(std::size_t i) const │ │ │ │ │ +Returns the i-th child (const version). │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:87 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_C_h_i_l_d_S_t_o_r_a_g_e_T_y_p_e │ │ │ │ │ +std::shared_ptr< T > ChildStorageType │ │ │ │ │ +The storage type of each child. │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:61 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e │ │ │ │ │ +DynamicPowerNode(T &t1, T &t2,...) │ │ │ │ │ +Initialize all children with the passed-in objects. │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:174 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_C_h_i_l_d_C_o_n_s_t_S_t_o_r_a_g_e_T_y_p_e │ │ │ │ │ +std::shared_ptr< const T > ChildConstStorageType │ │ │ │ │ +The const version of the storage type of each child. │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:64 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e │ │ │ │ │ +DynamicPowerNode(NodeStorage children) │ │ │ │ │ +Initialize the DynamicPowerNode with a copy of the passed-in storage type. │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:167 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_N_o_d_e_T_a_g │ │ │ │ │ +DynamicPowerNodeTag NodeTag │ │ │ │ │ +The type tag that describes the node. │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:55 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_C_h_i_l_d_T_y_p_e │ │ │ │ │ +T ChildType │ │ │ │ │ +The type of each child. │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:58 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ +void setChild(std::size_t i, ChildType &t) │ │ │ │ │ +Sets the i-th child to the passed-in value. │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:117 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ +void setChild(std::size_t i, ChildStorageType st) │ │ │ │ │ +Sets the stored value representing the i-th child to the passed-in value. │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:131 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e │ │ │ │ │ +DynamicPowerNode(std::size_t size) │ │ │ │ │ +Construct a node with the given number of children. │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:162 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_i_s_C_o_m_p_o_s_i_t_e │ │ │ │ │ +static const bool isComposite │ │ │ │ │ +Mark this class as a non composite in the dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:46 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ +void setChild(std::size_t i, ChildType &&t) │ │ │ │ │ +Store the passed value in i-th child. │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:124 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ +ChildType & child(std::size_t i) │ │ │ │ │ +Returns the i-th child. │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:77 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_d_e_g_r_e_e │ │ │ │ │ +std::size_t degree() const │ │ │ │ │ +The number of children. │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:49 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ +ChildStorageType childStorage(std::size_t i) │ │ │ │ │ +Returns the storage of the i-th child. │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:97 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_i_s_L_e_a_f │ │ │ │ │ +static const bool isLeaf │ │ │ │ │ +Mark this class as non leaf in the dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn dynamicpowernode.hh:40 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e │ │ │ │ │ +DynamicPowerNode()=delete │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g │ │ │ │ │ +Tag designating a power node with runtime degree. │ │ │ │ │ +DDeeffiinniittiioonn nodetags.hh:24 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00029.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: nodeinterface.hh File Reference │ │ │ │ +dune-typetree: fixedcapacitystack.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -71,60 +71,36 @@ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    │ │ │ │
    │ │ │ │ Classes | │ │ │ │ -Namespaces | │ │ │ │ -Typedefs | │ │ │ │ -Functions
    │ │ │ │ -
    nodeinterface.hh File Reference
    │ │ │ │ +Namespaces
    │ │ │ │ +
    fixedcapacitystack.hh File Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │ -
    #include <cstddef>
    │ │ │ │ -#include <type_traits>
    │ │ │ │ -#include <dune/common/documentation.hh>
    │ │ │ │ +
    #include <array>
    │ │ │ │ +#include <cassert>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
    │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  Dune::TypeTree::NodeInterface
     Interface for nodes in a dune-typetree. More...
    class  Dune::TypeTree::FixedCapacityStackView< T >
     
    class  Dune::TypeTree::FixedCapacityStack< T, capacity >
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
     
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -

    │ │ │ │ -Typedefs

    template<typename Node >
    using Dune::TypeTree::NodeTag = typename std::decay_t< Node >::NodeTag
     Returns the node tag of the given Node.
     
    template<typename T >
    using Dune::TypeTree::ImplementationTag = typename std::decay_t< T >::ImplementationTag
     Returns the implementation tag of the given Node.
     
    template<typename Node >
    using Dune::TypeTree::StaticDegree = decltype(Node::degree())
     Returns the statically known degree of the given Node type as a std::integral_constant.
     
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │

    │ │ │ │ -Functions

    template<typename Node >
    std::size_t Dune::TypeTree::degree (const Node &node)
     Returns the degree of node as run time information.
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,43 +1,23 @@ │ │ │ │ │ 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 | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s │ │ │ │ │ -nodeinterface.hh File Reference │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ +_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s │ │ │ │ │ +fixedcapacitystack.hh File Reference │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ _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_:_:_N_o_d_e_I_n_t_e_r_f_a_c_e │ │ │ │ │ -  Interface for nodes in a _d_u_n_e_-_t_y_p_e_t_r_e_e. _M_o_r_e_._._. │ │ │ │ │ +class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_<_ _T_ _> │ │ │ │ │ +  │ │ │ │ │ +class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_<_ _T_,_ _c_a_p_a_c_i_t_y_ _> │ │ │ │ │   │ │ │ │ │ NNaammeessppaacceess │ │ │ │ │ namespace   _D_u_n_e │ │ │ │ │   │ │ │ │ │ namespace   _D_u_n_e_:_:_T_y_p_e_T_r_e_e │ │ │ │ │   │ │ │ │ │ -TTyyppeeddeeffss │ │ │ │ │ -template │ │ │ │ │ -using  _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 │ │ │ │ │ -  Returns the node tag of the given Node. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ -using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_I_m_p_l_e_m_e_n_t_a_t_i_o_n_T_a_g = typename std::decay_t< T >:: │ │ │ │ │ - ImplementationTag │ │ │ │ │ -  Returns the implementation tag of the given Node. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ -using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_D_e_g_r_e_e = decltype(Node::degree()) │ │ │ │ │ -  Returns the statically known degree of the given Node type as a std:: │ │ │ │ │ - integral_constant. │ │ │ │ │ -  │ │ │ │ │ -FFuunnccttiioonnss │ │ │ │ │ -template │ │ │ │ │ -std::size_t  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_d_e_g_r_e_e (const Node &node) │ │ │ │ │ -  Returns the degree of node as run time information. │ │ │ │ │ -  │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00029_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: nodeinterface.hh Source File │ │ │ │ +dune-typetree: fixedcapacitystack.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,100 +74,215 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -
    nodeinterface.hh
    │ │ │ │ +
    fixedcapacitystack.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    1// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
    │ │ │ │
    2// vi: set et ts=8 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_NODEINTERFACE_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_NODEINTERFACE_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_FIXEDCAPACITYSTACK_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_FIXEDCAPACITYSTACK_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <cstddef>
    │ │ │ │ -
    10#include <type_traits>
    │ │ │ │ +
    9#include <array>
    │ │ │ │ +
    10#include <cassert>
    │ │ │ │
    11
    │ │ │ │ -
    12#include <dune/common/documentation.hh>
    │ │ │ │ -
    13
    │ │ │ │ -
    14namespace Dune {
    │ │ │ │ -
    15 namespace TypeTree {
    │ │ │ │ -
    16
    │ │ │ │ -
    │ │ │ │ -
    34 struct NodeInterface
    │ │ │ │ -
    35 {
    │ │ │ │ -
    37 static const bool isLeaf = implementationDefined;
    │ │ │ │ -
    38
    │ │ │ │ -
    40 static const bool isPower = implementationDefined;
    │ │ │ │ -
    41
    │ │ │ │ -
    43 static const bool isComposite = implementationDefined;
    │ │ │ │ -
    44
    │ │ │ │ -
    46
    │ │ │ │ -
    51 static auto degree();
    │ │ │ │ -
    52
    │ │ │ │ -
    54
    │ │ │ │ -
    59 typedef ImplementationDefined NodeTag;
    │ │ │ │ +
    12namespace Dune {
    │ │ │ │ +
    13 namespace TypeTree {
    │ │ │ │ +
    14
    │ │ │ │ +
    15
    │ │ │ │ +
    19
    │ │ │ │ +
    20 template<typename T>
    │ │ │ │ +
    │ │ │ │ +
    21 class FixedCapacityStackView
    │ │ │ │ +
    22 {
    │ │ │ │ +
    23
    │ │ │ │ +
    24 public:
    │ │ │ │ +
    25
    │ │ │ │ +
    26 struct Impl
    │ │ │ │ +
    27 {
    │ │ │ │ +
    28
    │ │ │ │ +
    29 Impl(T* data, std::size_t capacity)
    │ │ │ │ +
    30 : _data(data)
    │ │ │ │ +
    31 , _size(0)
    │ │ │ │ +
    32 , _capacity(capacity)
    │ │ │ │ +
    33 {}
    │ │ │ │ +
    34
    │ │ │ │ +
    35 T * const _data;
    │ │ │ │ +
    36 std::size_t _size;
    │ │ │ │ +
    37 const std::size_t _capacity;
    │ │ │ │ +
    38 };
    │ │ │ │ +
    39
    │ │ │ │ +
    │ │ │ │ +
    40 FixedCapacityStackView(Impl& impl)
    │ │ │ │ +
    41 : _impl(impl)
    │ │ │ │ +
    42 {}
    │ │ │ │ +
    │ │ │ │ +
    43
    │ │ │ │ +
    44 public:
    │ │ │ │ +
    45
    │ │ │ │ +
    │ │ │ │ +
    46 std::size_t size() const
    │ │ │ │ +
    47 {
    │ │ │ │ +
    48 return _impl._size;
    │ │ │ │ +
    49 }
    │ │ │ │ +
    │ │ │ │ +
    50
    │ │ │ │ +
    │ │ │ │ +
    51 std::size_t capacity() const
    │ │ │ │ +
    52 {
    │ │ │ │ +
    53 return _impl._capacity;
    │ │ │ │ +
    54 }
    │ │ │ │ +
    │ │ │ │ +
    55
    │ │ │ │ +
    │ │ │ │ +
    56 bool empty() const
    │ │ │ │ +
    57 {
    │ │ │ │ +
    58 return _impl._size == 0;
    │ │ │ │ +
    59 }
    │ │ │ │ +
    │ │ │ │
    60
    │ │ │ │ -
    62
    │ │ │ │ -
    65 typedef ImplementationDefined NodeStorage;
    │ │ │ │ -
    66 };
    │ │ │ │ -
    │ │ │ │ -
    67
    │ │ │ │ -
    69 template<typename Node>
    │ │ │ │ -
    70 using NodeTag = typename std::decay_t<Node>::NodeTag;
    │ │ │ │ +
    │ │ │ │ +
    61 bool full() const
    │ │ │ │ +
    62 {
    │ │ │ │ +
    63 return _impl._size == _impl._capacity;
    │ │ │ │ +
    64 }
    │ │ │ │ +
    │ │ │ │ +
    65
    │ │ │ │ +
    │ │ │ │ +
    66 void push_back(const T& t)
    │ │ │ │ +
    67 {
    │ │ │ │ +
    68 assert(!full());
    │ │ │ │ +
    69 _impl._data[_impl._size++] = t;
    │ │ │ │ +
    70 }
    │ │ │ │ +
    │ │ │ │
    71
    │ │ │ │ -
    73 template<typename T>
    │ │ │ │ -
    74 using ImplementationTag = typename std::decay_t<T>::ImplementationTag;
    │ │ │ │ -
    75
    │ │ │ │ -
    76
    │ │ │ │ -
    78 template<typename Node>
    │ │ │ │ -
    │ │ │ │ -
    79 std::size_t degree(const Node& node)
    │ │ │ │ -
    80 {
    │ │ │ │ -
    81 return degree(&node,NodeTag<Node>());
    │ │ │ │ -
    82 }
    │ │ │ │ +
    │ │ │ │ +
    72 void pop_back()
    │ │ │ │ +
    73 {
    │ │ │ │ +
    74 assert(!empty());
    │ │ │ │ +
    75 --_impl._size;
    │ │ │ │ +
    76 }
    │ │ │ │ +
    │ │ │ │ +
    77
    │ │ │ │ +
    │ │ │ │ +
    78 T& back()
    │ │ │ │ +
    79 {
    │ │ │ │ +
    80 assert(!empty());
    │ │ │ │ +
    81 return _impl._data[_impl._size-1];
    │ │ │ │ +
    82 }
    │ │ │ │
    │ │ │ │
    83
    │ │ │ │ -
    84#ifndef DOXYGEN
    │ │ │ │ -
    85
    │ │ │ │ -
    87
    │ │ │ │ -
    93 template<typename Node, typename NodeTag>
    │ │ │ │ -
    94 std::size_t degree(const Node* node, NodeTag)
    │ │ │ │ -
    95 {
    │ │ │ │ -
    96 return node->degree();
    │ │ │ │ -
    97 }
    │ │ │ │ -
    98
    │ │ │ │ -
    99#endif // DOXYGEN
    │ │ │ │ -
    100
    │ │ │ │ -
    102
    │ │ │ │ -
    106 template<typename Node>
    │ │ │ │ -
    107 using StaticDegree = decltype(Node::degree());
    │ │ │ │ -
    108
    │ │ │ │ -
    110
    │ │ │ │ -
    111 } // namespace TypeTree
    │ │ │ │ -
    112} //namespace Dune
    │ │ │ │ +
    │ │ │ │ +
    84 const T& back() const
    │ │ │ │ +
    85 {
    │ │ │ │ +
    86 assert(!empty());
    │ │ │ │ +
    87 return _impl._data[_impl._size-1];
    │ │ │ │ +
    88 }
    │ │ │ │ +
    │ │ │ │ +
    89
    │ │ │ │ +
    │ │ │ │ +
    90 T& front()
    │ │ │ │ +
    91 {
    │ │ │ │ +
    92 assert(!empty());
    │ │ │ │ +
    93 return _impl._data[0];
    │ │ │ │ +
    94 }
    │ │ │ │ +
    │ │ │ │ +
    95
    │ │ │ │ +
    │ │ │ │ +
    96 const T& front() const
    │ │ │ │ +
    97 {
    │ │ │ │ +
    98 assert(!empty());
    │ │ │ │ +
    99 return _impl._data[0];
    │ │ │ │ +
    100 }
    │ │ │ │ +
    │ │ │ │ +
    101
    │ │ │ │ +
    │ │ │ │ +
    102 T& operator[](std::size_t k)
    │ │ │ │ +
    103 {
    │ │ │ │ +
    104 assert(k < _impl._size);
    │ │ │ │ +
    105 return _impl._data[k];
    │ │ │ │ +
    106 }
    │ │ │ │ +
    │ │ │ │ +
    107
    │ │ │ │ +
    │ │ │ │ +
    108 const T& operator[](std::size_t k) const
    │ │ │ │ +
    109 {
    │ │ │ │ +
    110 assert(k < _impl._size);
    │ │ │ │ +
    111 return _impl._data[k];
    │ │ │ │ +
    112 }
    │ │ │ │ +
    │ │ │ │
    113
    │ │ │ │ -
    114#endif // DUNE_TYPETREE_NODEINTERFACE_HH
    │ │ │ │ -
    Dune::TypeTree::degree
    std::size_t degree(const Node &node)
    Returns the degree of node as run time information.
    Definition nodeinterface.hh:79
    │ │ │ │ -
    Dune::TypeTree::NodeTag
    typename std::decay_t< Node >::NodeTag NodeTag
    Returns the node tag of the given Node.
    Definition nodeinterface.hh:70
    │ │ │ │ -
    Dune::TypeTree::ImplementationTag
    typename std::decay_t< T >::ImplementationTag ImplementationTag
    Returns the implementation tag of the given Node.
    Definition nodeinterface.hh:74
    │ │ │ │ -
    Dune::TypeTree::StaticDegree
    decltype(Node::degree()) StaticDegree
    Returns the statically known degree of the given Node type as a std::integral_constant.
    Definition nodeinterface.hh:107
    │ │ │ │ +
    114 private:
    │ │ │ │ +
    115 Impl& _impl;
    │ │ │ │ +
    116
    │ │ │ │ +
    117 };
    │ │ │ │ +
    │ │ │ │ +
    118
    │ │ │ │ +
    119
    │ │ │ │ +
    120 template<typename T, std::size_t capacity>
    │ │ │ │ +
    │ │ │ │ +
    121 class FixedCapacityStack
    │ │ │ │ +
    122 : private std::array<T,capacity>
    │ │ │ │ +
    123 , private FixedCapacityStackView<T>::Impl
    │ │ │ │ +
    124 , public FixedCapacityStackView<T>
    │ │ │ │ +
    125 {
    │ │ │ │ +
    126
    │ │ │ │ +
    127 typedef FixedCapacityStackView<T> view_base;
    │ │ │ │ +
    128
    │ │ │ │ +
    129 public:
    │ │ │ │ +
    130
    │ │ │ │ +
    131 using view_base::back;
    │ │ │ │ +
    132 using view_base::front;
    │ │ │ │ +
    133 using view_base::size;
    │ │ │ │ +
    134 using view_base::operator[];
    │ │ │ │ +
    135
    │ │ │ │ +
    │ │ │ │ +
    136 FixedCapacityStack()
    │ │ │ │ +
    137 : FixedCapacityStackView<T>::Impl(&(static_cast<std::array<T,capacity>&>(*this)[0]),capacity)
    │ │ │ │ +
    138 , FixedCapacityStackView<T>(static_cast<typename FixedCapacityStackView<T>::Impl&>(*this))
    │ │ │ │ +
    139 {}
    │ │ │ │ +
    │ │ │ │ +
    140
    │ │ │ │ +
    141 private:
    │ │ │ │ +
    142
    │ │ │ │ +
    143 //FixedCapacityStack(const FixedCapacityStack&);
    │ │ │ │ +
    144 FixedCapacityStack& operator=(const FixedCapacityStack&);
    │ │ │ │ +
    145
    │ │ │ │ +
    146 };
    │ │ │ │ +
    │ │ │ │ +
    147
    │ │ │ │ +
    149
    │ │ │ │ +
    150 } // namespace TypeTree
    │ │ │ │ +
    151} //namespace Dune
    │ │ │ │ +
    152
    │ │ │ │ +
    153#endif // DUNE_TYPETREE_FIXEDCAPACITYSTACK_HH
    │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::NodeInterface
    Interface for nodes in a dune-typetree.
    Definition nodeinterface.hh:35
    │ │ │ │ -
    Dune::TypeTree::NodeInterface::degree
    static auto degree()
    Number of children of this node in the dune-typetree.
    │ │ │ │ -
    Dune::TypeTree::NodeInterface::isPower
    static const bool isPower
    Whether this is a power node in the dune-typetree.
    Definition nodeinterface.hh:40
    │ │ │ │ -
    Dune::TypeTree::NodeInterface::isLeaf
    static const bool isLeaf
    Whether this is a leaf node in a dune-typetree.
    Definition nodeinterface.hh:37
    │ │ │ │ -
    Dune::TypeTree::NodeInterface::NodeStorage
    ImplementationDefined NodeStorage
    container type to pass around a collection of children
    Definition nodeinterface.hh:65
    │ │ │ │ -
    Dune::TypeTree::NodeInterface::isComposite
    static const bool isComposite
    Whether this is a composite node in the dune-typetree.
    Definition nodeinterface.hh:43
    │ │ │ │ -
    Dune::TypeTree::NodeInterface::NodeTag
    ImplementationDefined NodeTag
    The type tag that describes what kind of node this is.
    Definition nodeinterface.hh:59
    │ │ │ │ +
    Dune::TypeTree::FixedCapacityStackView
    Definition fixedcapacitystack.hh:22
    │ │ │ │ +
    Dune::TypeTree::FixedCapacityStackView::empty
    bool empty() const
    Definition fixedcapacitystack.hh:56
    │ │ │ │ +
    Dune::TypeTree::FixedCapacityStackView::full
    bool full() const
    Definition fixedcapacitystack.hh:61
    │ │ │ │ +
    Dune::TypeTree::FixedCapacityStackView::operator[]
    T & operator[](std::size_t k)
    Definition fixedcapacitystack.hh:102
    │ │ │ │ +
    Dune::TypeTree::FixedCapacityStackView::pop_back
    void pop_back()
    Definition fixedcapacitystack.hh:72
    │ │ │ │ +
    Dune::TypeTree::FixedCapacityStackView::back
    T & back()
    Definition fixedcapacitystack.hh:78
    │ │ │ │ +
    Dune::TypeTree::FixedCapacityStackView::capacity
    std::size_t capacity() const
    Definition fixedcapacitystack.hh:51
    │ │ │ │ +
    Dune::TypeTree::FixedCapacityStackView::front
    T & front()
    Definition fixedcapacitystack.hh:90
    │ │ │ │ +
    Dune::TypeTree::FixedCapacityStackView::front
    const T & front() const
    Definition fixedcapacitystack.hh:96
    │ │ │ │ +
    Dune::TypeTree::FixedCapacityStackView::operator[]
    const T & operator[](std::size_t k) const
    Definition fixedcapacitystack.hh:108
    │ │ │ │ +
    Dune::TypeTree::FixedCapacityStackView::push_back
    void push_back(const T &t)
    Definition fixedcapacitystack.hh:66
    │ │ │ │ +
    Dune::TypeTree::FixedCapacityStackView::back
    const T & back() const
    Definition fixedcapacitystack.hh:84
    │ │ │ │ +
    Dune::TypeTree::FixedCapacityStackView::size
    std::size_t size() const
    Definition fixedcapacitystack.hh:46
    │ │ │ │ +
    Dune::TypeTree::FixedCapacityStackView::FixedCapacityStackView
    FixedCapacityStackView(Impl &impl)
    Definition fixedcapacitystack.hh:40
    │ │ │ │ +
    Dune::TypeTree::FixedCapacityStack
    Definition fixedcapacitystack.hh:125
    │ │ │ │ +
    Dune::TypeTree::FixedCapacityStack::FixedCapacityStack
    FixedCapacityStack()
    Definition fixedcapacitystack.hh:136
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,124 +1,211 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -nodeinterface.hh │ │ │ │ │ +fixedcapacitystack.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: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- │ │ │ │ │ 2// vi: set et ts=8 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_NODEINTERFACE_HH │ │ │ │ │ -7#define DUNE_TYPETREE_NODEINTERFACE_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_FIXEDCAPACITYSTACK_HH │ │ │ │ │ +7#define DUNE_TYPETREE_FIXEDCAPACITYSTACK_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include │ │ │ │ │ -10#include │ │ │ │ │ +9#include │ │ │ │ │ +10#include │ │ │ │ │ 11 │ │ │ │ │ -12#include │ │ │ │ │ -13 │ │ │ │ │ -14namespace _D_u_n_e { │ │ │ │ │ -15 namespace TypeTree { │ │ │ │ │ -16 │ │ │ │ │ -_3_4 struct _N_o_d_e_I_n_t_e_r_f_a_c_e │ │ │ │ │ -35 { │ │ │ │ │ -_3_7 static const bool _i_s_L_e_a_f = implementationDefined; │ │ │ │ │ -38 │ │ │ │ │ -_4_0 static const bool _i_s_P_o_w_e_r = implementationDefined; │ │ │ │ │ -41 │ │ │ │ │ -_4_3 static const bool _i_s_C_o_m_p_o_s_i_t_e = implementationDefined; │ │ │ │ │ -44 │ │ │ │ │ -46 │ │ │ │ │ -_5_1 static auto _d_e_g_r_e_e(); │ │ │ │ │ -52 │ │ │ │ │ -54 │ │ │ │ │ -_5_9 typedef ImplementationDefined _N_o_d_e_T_a_g; │ │ │ │ │ +12namespace _D_u_n_e { │ │ │ │ │ +13 namespace TypeTree { │ │ │ │ │ +14 │ │ │ │ │ +15 │ │ │ │ │ +19 │ │ │ │ │ +20 template │ │ │ │ │ +_2_1 class _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w │ │ │ │ │ +22 { │ │ │ │ │ +23 │ │ │ │ │ +24 public: │ │ │ │ │ +25 │ │ │ │ │ +26 struct Impl │ │ │ │ │ +27 { │ │ │ │ │ +28 │ │ │ │ │ +29 Impl(T* data, std::size_t _c_a_p_a_c_i_t_y) │ │ │ │ │ +30 : _data(data) │ │ │ │ │ +31 , _size(0) │ │ │ │ │ +32 , _capacity(_c_a_p_a_c_i_t_y) │ │ │ │ │ +33 {} │ │ │ │ │ +34 │ │ │ │ │ +35 T * const _data; │ │ │ │ │ +36 std::size_t _size; │ │ │ │ │ +37 const std::size_t _capacity; │ │ │ │ │ +38 }; │ │ │ │ │ +39 │ │ │ │ │ +_4_0 _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w(Impl& impl) │ │ │ │ │ +41 : _impl(impl) │ │ │ │ │ +42 {} │ │ │ │ │ +43 │ │ │ │ │ +44 public: │ │ │ │ │ +45 │ │ │ │ │ +_4_6 std::size_t _s_i_z_e() const │ │ │ │ │ +47 { │ │ │ │ │ +48 return _impl._size; │ │ │ │ │ +49 } │ │ │ │ │ +50 │ │ │ │ │ +_5_1 std::size_t _c_a_p_a_c_i_t_y() const │ │ │ │ │ +52 { │ │ │ │ │ +53 return _impl._capacity; │ │ │ │ │ +54 } │ │ │ │ │ +55 │ │ │ │ │ +_5_6 bool _e_m_p_t_y() const │ │ │ │ │ +57 { │ │ │ │ │ +58 return _impl._size == 0; │ │ │ │ │ +59 } │ │ │ │ │ 60 │ │ │ │ │ -62 │ │ │ │ │ -_6_5 typedef ImplementationDefined _N_o_d_e_S_t_o_r_a_g_e; │ │ │ │ │ -66 }; │ │ │ │ │ -67 │ │ │ │ │ -69 template │ │ │ │ │ -_7_0 using _N_o_d_e_T_a_g = typename std::decay_t::NodeTag; │ │ │ │ │ +_6_1 bool _f_u_l_l() const │ │ │ │ │ +62 { │ │ │ │ │ +63 return _impl._size == _impl._capacity; │ │ │ │ │ +64 } │ │ │ │ │ +65 │ │ │ │ │ +_6_6 void _p_u_s_h___b_a_c_k(const T& t) │ │ │ │ │ +67 { │ │ │ │ │ +68 assert(!_f_u_l_l()); │ │ │ │ │ +69 _impl._data[_impl._size++] = t; │ │ │ │ │ +70 } │ │ │ │ │ 71 │ │ │ │ │ -73 template │ │ │ │ │ -_7_4 using _I_m_p_l_e_m_e_n_t_a_t_i_o_n_T_a_g = typename std::decay_t::ImplementationTag; │ │ │ │ │ -75 │ │ │ │ │ -76 │ │ │ │ │ -78 template │ │ │ │ │ -_7_9 std::size_t _d_e_g_r_e_e(const Node& node) │ │ │ │ │ -80 { │ │ │ │ │ -81 return _d_e_g_r_e_e(&node,_N_o_d_e_T_a_g_<_N_o_d_e_>()); │ │ │ │ │ +_7_2 void _p_o_p___b_a_c_k() │ │ │ │ │ +73 { │ │ │ │ │ +74 assert(!_e_m_p_t_y()); │ │ │ │ │ +75 --_impl._size; │ │ │ │ │ +76 } │ │ │ │ │ +77 │ │ │ │ │ +_7_8 T& _b_a_c_k() │ │ │ │ │ +79 { │ │ │ │ │ +80 assert(!_e_m_p_t_y()); │ │ │ │ │ +81 return _impl._data[_impl._size-1]; │ │ │ │ │ 82 } │ │ │ │ │ 83 │ │ │ │ │ -84#ifndef DOXYGEN │ │ │ │ │ -85 │ │ │ │ │ -87 │ │ │ │ │ -93 template │ │ │ │ │ -94 std::size_t _d_e_g_r_e_e(const Node* node, _N_o_d_e_T_a_g) │ │ │ │ │ -95 { │ │ │ │ │ -96 return node->degree(); │ │ │ │ │ -97 } │ │ │ │ │ -98 │ │ │ │ │ -99#endif // DOXYGEN │ │ │ │ │ -100 │ │ │ │ │ -102 │ │ │ │ │ -106 template │ │ │ │ │ -_1_0_7 using _S_t_a_t_i_c_D_e_g_r_e_e = decltype(Node::degree()); │ │ │ │ │ -108 │ │ │ │ │ -110 │ │ │ │ │ -111 } // namespace TypeTree │ │ │ │ │ -112} //namespace Dune │ │ │ │ │ +_8_4 const T& _b_a_c_k() const │ │ │ │ │ +85 { │ │ │ │ │ +86 assert(!_e_m_p_t_y()); │ │ │ │ │ +87 return _impl._data[_impl._size-1]; │ │ │ │ │ +88 } │ │ │ │ │ +89 │ │ │ │ │ +_9_0 T& _f_r_o_n_t() │ │ │ │ │ +91 { │ │ │ │ │ +92 assert(!_e_m_p_t_y()); │ │ │ │ │ +93 return _impl._data[0]; │ │ │ │ │ +94 } │ │ │ │ │ +95 │ │ │ │ │ +_9_6 const T& _f_r_o_n_t() const │ │ │ │ │ +97 { │ │ │ │ │ +98 assert(!_e_m_p_t_y()); │ │ │ │ │ +99 return _impl._data[0]; │ │ │ │ │ +100 } │ │ │ │ │ +101 │ │ │ │ │ +_1_0_2 T& _o_p_e_r_a_t_o_r_[_](std::size_t k) │ │ │ │ │ +103 { │ │ │ │ │ +104 assert(k < _impl._size); │ │ │ │ │ +105 return _impl._data[k]; │ │ │ │ │ +106 } │ │ │ │ │ +107 │ │ │ │ │ +_1_0_8 const T& _o_p_e_r_a_t_o_r_[_](std::size_t k) const │ │ │ │ │ +109 { │ │ │ │ │ +110 assert(k < _impl._size); │ │ │ │ │ +111 return _impl._data[k]; │ │ │ │ │ +112 } │ │ │ │ │ 113 │ │ │ │ │ -114#endif // DUNE_TYPETREE_NODEINTERFACE_HH │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_d_e_g_r_e_e │ │ │ │ │ -std::size_t degree(const Node &node) │ │ │ │ │ -Returns the degree of node as run time information. │ │ │ │ │ -DDeeffiinniittiioonn nodeinterface.hh:79 │ │ │ │ │ -_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_:_:_I_m_p_l_e_m_e_n_t_a_t_i_o_n_T_a_g │ │ │ │ │ -typename std::decay_t< T >::ImplementationTag ImplementationTag │ │ │ │ │ -Returns the implementation tag of the given Node. │ │ │ │ │ -DDeeffiinniittiioonn nodeinterface.hh:74 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_D_e_g_r_e_e │ │ │ │ │ -decltype(Node::degree()) StaticDegree │ │ │ │ │ -Returns the statically known degree of the given Node type as a std:: │ │ │ │ │ -integral_constant. │ │ │ │ │ -DDeeffiinniittiioonn nodeinterface.hh:107 │ │ │ │ │ +114 private: │ │ │ │ │ +115 Impl& _impl; │ │ │ │ │ +116 │ │ │ │ │ +117 }; │ │ │ │ │ +118 │ │ │ │ │ +119 │ │ │ │ │ +120 template │ │ │ │ │ +_1_2_1 class _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k │ │ │ │ │ +122 : private std::array │ │ │ │ │ +123 , private _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w::Impl │ │ │ │ │ +124 , public _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w │ │ │ │ │ +125 { │ │ │ │ │ +126 │ │ │ │ │ +127 typedef _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_<_T_> _v_i_e_w___b_a_s_e; │ │ │ │ │ +128 │ │ │ │ │ +129 public: │ │ │ │ │ +130 │ │ │ │ │ +131 using _v_i_e_w___b_a_s_e_:_:_b_a_c_k; │ │ │ │ │ +132 using _v_i_e_w___b_a_s_e_:_:_f_r_o_n_t; │ │ │ │ │ +133 using _v_i_e_w___b_a_s_e_:_:_s_i_z_e; │ │ │ │ │ +134 using view_base::operator[]; │ │ │ │ │ +135 │ │ │ │ │ +_1_3_6 _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k() │ │ │ │ │ +137 : _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w::Impl(&(static_cast&> │ │ │ │ │ +(*this)[0]),_c_a_p_a_c_i_t_y) │ │ │ │ │ +138 , _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w(static_cast::Impl&>(*this)) │ │ │ │ │ +139 {} │ │ │ │ │ +140 │ │ │ │ │ +141 private: │ │ │ │ │ +142 │ │ │ │ │ +143 //FixedCapacityStack(const FixedCapacityStack&); │ │ │ │ │ +144 _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k& operator=(const _F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k&); │ │ │ │ │ +145 │ │ │ │ │ +146 }; │ │ │ │ │ +147 │ │ │ │ │ +149 │ │ │ │ │ +150 } // namespace TypeTree │ │ │ │ │ +151} //namespace Dune │ │ │ │ │ +152 │ │ │ │ │ +153#endif // DUNE_TYPETREE_FIXEDCAPACITYSTACK_HH │ │ │ │ │ _D_u_n_e │ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_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 │ │ │ │ │ -Interface for nodes in a dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn nodeinterface.hh:35 │ │ │ │ │ -_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_:_:_d_e_g_r_e_e │ │ │ │ │ -static auto degree() │ │ │ │ │ -Number of children of this node in the dune-typetree. │ │ │ │ │ -_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_:_:_i_s_P_o_w_e_r │ │ │ │ │ -static const bool isPower │ │ │ │ │ -Whether this is a power node in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn nodeinterface.hh:40 │ │ │ │ │ -_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_:_:_i_s_L_e_a_f │ │ │ │ │ -static const bool isLeaf │ │ │ │ │ -Whether this is a leaf node in a dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn nodeinterface.hh:37 │ │ │ │ │ -_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_:_:_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ -ImplementationDefined NodeStorage │ │ │ │ │ -container type to pass around a collection of children │ │ │ │ │ -DDeeffiinniittiioonn nodeinterface.hh:65 │ │ │ │ │ -_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_:_:_i_s_C_o_m_p_o_s_i_t_e │ │ │ │ │ -static const bool isComposite │ │ │ │ │ -Whether this is a composite node in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn nodeinterface.hh:43 │ │ │ │ │ -_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_:_:_N_o_d_e_T_a_g │ │ │ │ │ -ImplementationDefined NodeTag │ │ │ │ │ -The type tag that describes what kind of node this is. │ │ │ │ │ -DDeeffiinniittiioonn nodeinterface.hh:59 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w │ │ │ │ │ +DDeeffiinniittiioonn fixedcapacitystack.hh:22 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_e_m_p_t_y │ │ │ │ │ +bool empty() const │ │ │ │ │ +DDeeffiinniittiioonn fixedcapacitystack.hh:56 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_f_u_l_l │ │ │ │ │ +bool full() const │ │ │ │ │ +DDeeffiinniittiioonn fixedcapacitystack.hh:61 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_o_p_e_r_a_t_o_r_[_] │ │ │ │ │ +T & operator[](std::size_t k) │ │ │ │ │ +DDeeffiinniittiioonn fixedcapacitystack.hh:102 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_p_o_p___b_a_c_k │ │ │ │ │ +void pop_back() │ │ │ │ │ +DDeeffiinniittiioonn fixedcapacitystack.hh:72 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_b_a_c_k │ │ │ │ │ +T & back() │ │ │ │ │ +DDeeffiinniittiioonn fixedcapacitystack.hh:78 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_c_a_p_a_c_i_t_y │ │ │ │ │ +std::size_t capacity() const │ │ │ │ │ +DDeeffiinniittiioonn fixedcapacitystack.hh:51 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_f_r_o_n_t │ │ │ │ │ +T & front() │ │ │ │ │ +DDeeffiinniittiioonn fixedcapacitystack.hh:90 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_f_r_o_n_t │ │ │ │ │ +const T & front() const │ │ │ │ │ +DDeeffiinniittiioonn fixedcapacitystack.hh:96 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_o_p_e_r_a_t_o_r_[_] │ │ │ │ │ +const T & operator[](std::size_t k) const │ │ │ │ │ +DDeeffiinniittiioonn fixedcapacitystack.hh:108 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_p_u_s_h___b_a_c_k │ │ │ │ │ +void push_back(const T &t) │ │ │ │ │ +DDeeffiinniittiioonn fixedcapacitystack.hh:66 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_b_a_c_k │ │ │ │ │ +const T & back() const │ │ │ │ │ +DDeeffiinniittiioonn fixedcapacitystack.hh:84 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_s_i_z_e │ │ │ │ │ +std::size_t size() const │ │ │ │ │ +DDeeffiinniittiioonn fixedcapacitystack.hh:46 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_V_i_e_w │ │ │ │ │ +FixedCapacityStackView(Impl &impl) │ │ │ │ │ +DDeeffiinniittiioonn fixedcapacitystack.hh:40 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k │ │ │ │ │ +DDeeffiinniittiioonn fixedcapacitystack.hh:125 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k_:_:_F_i_x_e_d_C_a_p_a_c_i_t_y_S_t_a_c_k │ │ │ │ │ +FixedCapacityStack() │ │ │ │ │ +DDeeffiinniittiioonn fixedcapacitystack.hh:136 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00032.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: accumulate_static.hh File Reference │ │ │ │ +dune-typetree: typetree.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -69,136 +69,32 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -
    │ │ │ │ -Classes | │ │ │ │ -Namespaces | │ │ │ │ -Functions
    │ │ │ │ -
    accumulate_static.hh File Reference
    │ │ │ │ +
    typetree.hh File Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │ -
    #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/nodetags.hh>
    │ │ │ │ +#include <dune/typetree/utility.hh>
    │ │ │ │ +#include <dune/typetree/leafnode.hh>
    │ │ │ │ +#include <dune/typetree/powernode.hh>
    │ │ │ │ +#include <dune/typetree/dynamicpowernode.hh>
    │ │ │ │ +#include <dune/typetree/compositenode.hh>
    │ │ │ │ +#include <dune/typetree/traversal.hh>
    │ │ │ │ +#include <dune/typetree/pairtraversal.hh>
    │ │ │ │ +#include <dune/typetree/traversalutilities.hh>
    │ │ │ │ +#include <dune/typetree/transformation.hh>
    │ │ │ │ +#include <dune/typetree/transformationutilities.hh>
    │ │ │ │ +#include <dune/typetree/accumulate_static.hh>
    │ │ │ │ +#include <dune/typetree/childextraction.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.
     
    │ │ │ │ -

    Variable Documentation

    │ │ │ │ - │ │ │ │ -

    ◆ child_result

    │ │ │ │ - │ │ │ │ -
    │ │ │ │ -
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -
    const result_type child_result = accumulate_value<child,Functor,Reduction,ParentChildReduction,current_value,child_tree_path,NodeTag<child>>::result
    │ │ │ │ -     		│ │ │ │ -static
    │ │ │ │ -
    │ │ │ │ - │ │ │ │ -
    │ │ │ │ -
    │ │ │ │ - │ │ │ │ -

    ◆ result

    │ │ │ │ - │ │ │ │ -
    │ │ │ │ -
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -
    const result_type result = current_value
    │ │ │ │ -     		│ │ │ │ -static
    │ │ │ │ -
    │ │ │ │ - │ │ │ │ -
    │ │ │ │ -
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,84 +1,23 @@ │ │ │ │ │ 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> │ │ │ │ │ +typetree.hh File Reference │ │ │ │ │ #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> │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_l_e_a_f_n_o_d_e_._h_h> │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_p_o_w_e_r_n_o_d_e_._h_h> │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_d_y_n_a_m_i_c_p_o_w_e_r_n_o_d_e_._h_h> │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_c_o_m_p_o_s_i_t_e_n_o_d_e_._h_h> │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_v_e_r_s_a_l_._h_h> │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_p_a_i_r_t_r_a_v_e_r_s_a_l_._h_h> │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_v_e_r_s_a_l_u_t_i_l_i_t_i_e_s_._h_h> │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_n_s_f_o_r_m_a_t_i_o_n_._h_h> │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_n_s_f_o_r_m_a_t_i_o_n_u_t_i_l_i_t_i_e_s_._h_h> │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_a_c_c_u_m_u_l_a_t_e___s_t_a_t_i_c_._h_h> │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._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. │ │ │ │ │ -  │ │ │ │ │ -********** 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 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00032_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: accumulate_static.hh Source File │ │ │ │ +dune-typetree: typetree.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,595 +74,53 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -
    accumulate_static.hh
    │ │ │ │ +
    typetree.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <dune/common/typetraits.hh>
    │ │ │ │ -
    10#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ -
    11#include <dune/typetree/nodetags.hh>
    │ │ │ │ -
    12#include <dune/typetree/treepath.hh>
    │ │ │ │ -
    13#include <dune/typetree/utility.hh>
    │ │ │ │ -
    14
    │ │ │ │ -
    15
    │ │ │ │ -
    │ │ │ │ -
    16namespace Dune {
    │ │ │ │ -
    │ │ │ │ -
    17 namespace TypeTree {
    │ │ │ │ -
    18
    │ │ │ │ -
    25 template<typename result_type>
    │ │ │ │ -
    │ │ │ │ -
    26 struct or_
    │ │ │ │ -
    27 {
    │ │ │ │ -
    28 template<result_type r1, result_type r2>
    │ │ │ │ -
    │ │ │ │ -
    29 struct reduce
    │ │ │ │ -
    30 {
    │ │ │ │ -
    31 static const result_type result = r1 || r2;
    │ │ │ │ -
    32 };
    │ │ │ │ -
    │ │ │ │ -
    33 };
    │ │ │ │ -
    │ │ │ │ -
    34
    │ │ │ │ -
    36 template<typename result_type>
    │ │ │ │ -
    │ │ │ │ -
    37 struct and_
    │ │ │ │ -
    38 {
    │ │ │ │ -
    39 template<result_type r1, result_type r2>
    │ │ │ │ -
    │ │ │ │ -
    40 struct reduce
    │ │ │ │ -
    41 {
    │ │ │ │ -
    42 static const result_type result = r1 && r2;
    │ │ │ │ -
    43 };
    │ │ │ │ -
    │ │ │ │ -
    44 };
    │ │ │ │ -
    │ │ │ │ -
    45
    │ │ │ │ -
    47 template<typename result_type>
    │ │ │ │ -
    │ │ │ │ -
    48 struct plus
    │ │ │ │ -
    49 {
    │ │ │ │ -
    50 template<result_type r1, result_type r2>
    │ │ │ │ -
    │ │ │ │ -
    51 struct reduce
    │ │ │ │ -
    52 {
    │ │ │ │ -
    53 static const result_type result = r1 + r2;
    │ │ │ │ -
    54 };
    │ │ │ │ -
    │ │ │ │ -
    55 };
    │ │ │ │ -
    │ │ │ │ -
    56
    │ │ │ │ -
    58 template<typename result_type>
    │ │ │ │ -
    │ │ │ │ -
    59 struct minus
    │ │ │ │ -
    60 {
    │ │ │ │ -
    61 template<result_type r1, result_type r2>
    │ │ │ │ -
    │ │ │ │ -
    62 struct reduce
    │ │ │ │ -
    63 {
    │ │ │ │ -
    64 static const result_type result = r1 - r2;
    │ │ │ │ -
    65 };
    │ │ │ │ -
    │ │ │ │ -
    66 };
    │ │ │ │ -
    │ │ │ │ -
    67
    │ │ │ │ -
    69 template<typename result_type>
    │ │ │ │ -
    │ │ │ │ -
    70 struct multiply
    │ │ │ │ -
    71 {
    │ │ │ │ -
    72 template<result_type r1, result_type r2>
    │ │ │ │ -
    │ │ │ │ -
    73 struct reduce
    │ │ │ │ -
    74 {
    │ │ │ │ -
    75 static const result_type result = r1 * r2;
    │ │ │ │ -
    76 };
    │ │ │ │ -
    │ │ │ │ -
    77 };
    │ │ │ │ -
    │ │ │ │ -
    78
    │ │ │ │ -
    80 template<typename result_type>
    │ │ │ │ -
    │ │ │ │ -
    81 struct min
    │ │ │ │ -
    82 {
    │ │ │ │ -
    83 template<result_type r1, result_type r2>
    │ │ │ │ -
    │ │ │ │ -
    84 struct reduce
    │ │ │ │ -
    85 {
    │ │ │ │ -
    86 static const result_type result = r1 < r2 ? r1 : r2;
    │ │ │ │ -
    87 };
    │ │ │ │ -
    │ │ │ │ -
    88 };
    │ │ │ │ -
    │ │ │ │ -
    89
    │ │ │ │ -
    91 template<typename result_type>
    │ │ │ │ -
    │ │ │ │ -
    92 struct max
    │ │ │ │ -
    93 {
    │ │ │ │ -
    94 template<result_type r1, result_type r2>
    │ │ │ │ -
    │ │ │ │ -
    95 struct reduce
    │ │ │ │ -
    96 {
    │ │ │ │ -
    97 static const result_type result = r1 > r2 ? r1 : r2;
    │ │ │ │ -
    98 };
    │ │ │ │ -
    │ │ │ │ -
    99 };
    │ │ │ │ -
    │ │ │ │ -
    100
    │ │ │ │ -
    101
    │ │ │ │ -
    102 namespace {
    │ │ │ │ -
    103
    │ │ │ │ -
    104 // implementation of the traversal algorithm
    │ │ │ │ -
    105
    │ │ │ │ -
    107 template<typename Node, typename Functor, typename Reduction, typename Functor::result_type current_value, typename TreePath, bool doVisit>
    │ │ │ │ -
    108 struct accumulate_node_helper
    │ │ │ │ -
    109 {
    │ │ │ │ -
    110
    │ │ │ │ -
    111 typedef typename Functor::result_type result_type;
    │ │ │ │ -
    112
    │ │ │ │ -
    113 static const result_type result = current_value;
    │ │ │ │ -
    114
    │ │ │ │ -
    115 };
    │ │ │ │ -
    116
    │ │ │ │ -
    118 template<typename Node, typename Functor, typename Reduction, typename Functor::result_type current_value, typename TreePath>
    │ │ │ │ -
    119 struct accumulate_node_helper<Node,Functor,Reduction,current_value,TreePath,true>
    │ │ │ │ -
    120 {
    │ │ │ │ -
    121
    │ │ │ │ -
    122 typedef typename Functor::result_type result_type;
    │ │ │ │ -
    123
    │ │ │ │ -
    124 static const result_type result = Reduction::template reduce<current_value,Functor::template visit<Node,TreePath>::result>::result;
    │ │ │ │ -
    125
    │ │ │ │ -
    126 };
    │ │ │ │ -
    127
    │ │ │ │ -
    129 template<typename Tree, typename Functor, typename Reduction, typename ParentChildReduction, typename Functor::result_type current_value, typename TreePath, typename Tag>
    │ │ │ │ -
    130 struct accumulate_value;
    │ │ │ │ -
    131
    │ │ │ │ -
    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>
    │ │ │ │ -
    135 {
    │ │ │ │ -
    136
    │ │ │ │ -
    137 typedef typename Functor::result_type result_type;
    │ │ │ │ -
    138
    │ │ │ │ -
    139 static const result_type result =
    │ │ │ │ -
    140
    │ │ │ │ -
    141 accumulate_node_helper<LeafNode,Functor,Reduction,current_value,TreePath,Functor::template doVisit<LeafNode,TreePath>::value>::result;
    │ │ │ │ -
    142
    │ │ │ │ -
    143 };
    │ │ │ │ -
    144
    │ │ │ │ -
    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>
    │ │ │ │ -
    147 struct accumulate_over_children
    │ │ │ │ -
    148 {
    │ │ │ │ -
    149
    │ │ │ │ -
    150 typedef typename Functor::result_type result_type;
    │ │ │ │ -
    151
    │ │ │ │ -
    152 typedef decltype(push_back(TreePath{},index_constant<i>{})) child_tree_path;
    │ │ │ │ -
    153
    │ │ │ │ -
    154 typedef typename Node::template Child<i>::Type child;
    │ │ │ │ -
    155
    │ │ │ │ -
    156 static const result_type child_result = accumulate_value<child,Functor,Reduction,ParentChildReduction,current_value,child_tree_path,NodeTag<child>>::result;
    │ │ │ │ -
    157
    │ │ │ │ -
    158 static const result_type result = accumulate_over_children<Node,Functor,Reduction,ParentChildReduction,child_result,TreePath,i+1,n>::result;
    │ │ │ │ -
    159
    │ │ │ │ -
    160 };
    │ │ │ │ -
    161
    │ │ │ │ -
    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>
    │ │ │ │ -
    165 {
    │ │ │ │ -
    166
    │ │ │ │ -
    167 typedef typename Functor::result_type result_type;
    │ │ │ │ -
    168
    │ │ │ │ -
    169 static const result_type result = current_value;
    │ │ │ │ -
    170
    │ │ │ │ -
    171 };
    │ │ │ │ -
    172
    │ │ │ │ -
    175 template<typename Node, typename Functor, typename Reduction, typename ParentChildReduction, typename Functor::result_type current_value, typename TreePath>
    │ │ │ │ -
    176 struct accumulate_value_generic_composite_node
    │ │ │ │ -
    177 {
    │ │ │ │ -
    178
    │ │ │ │ -
    179 typedef typename Functor::result_type result_type;
    │ │ │ │ -
    180
    │ │ │ │ -
    181 static const result_type child_result = accumulate_over_children<Node,Functor,Reduction,ParentChildReduction,current_value,TreePath,0,StaticDegree<Node>::value>::result;
    │ │ │ │ -
    182
    │ │ │ │ -
    183 static const result_type result =
    │ │ │ │ -
    184 accumulate_node_helper<Node,Functor,ParentChildReduction,child_result,TreePath,Functor::template doVisit<Node,TreePath>::value>::result;
    │ │ │ │ -
    185
    │ │ │ │ -
    186
    │ │ │ │ -
    187 };
    │ │ │ │ -
    188
    │ │ │ │ -
    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>
    │ │ │ │ -
    193 {};
    │ │ │ │ -
    194
    │ │ │ │ -
    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>
    │ │ │ │ -
    199 {};
    │ │ │ │ -
    200
    │ │ │ │ -
    201 } // anonymous namespace
    │ │ │ │ -
    202
    │ │ │ │ -
    204
    │ │ │ │ -
    260 template<typename Tree, typename Functor, typename Reduction, typename Functor::result_type startValue, typename ParentChildReduction = Reduction>
    │ │ │ │ -
    │ │ │ │ -
    261 struct AccumulateValue
    │ │ │ │ -
    262 {
    │ │ │ │ -
    263
    │ │ │ │ -
    265 typedef typename Functor::result_type result_type;
    │ │ │ │ -
    266
    │ │ │ │ -
    268 static const result_type result = accumulate_value<Tree,Functor,Reduction,ParentChildReduction,startValue,HybridTreePath<>,NodeTag<Tree>>::result;
    │ │ │ │ -
    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<typename Node, typename Functor, typename Reduction, typename current_type, typename TreePath, bool doVisit>
    │ │ │ │ -
    287 struct accumulate_type_node_helper
    │ │ │ │ -
    288 {
    │ │ │ │ -
    289
    │ │ │ │ -
    290 typedef current_type type;
    │ │ │ │ -
    291
    │ │ │ │ -
    292 };
    │ │ │ │ -
    293
    │ │ │ │ -
    295 template<typename Node, typename Functor, typename Reduction, typename current_type, typename TreePath>
    │ │ │ │ -
    296 struct accumulate_type_node_helper<Node,Functor,Reduction,current_type,TreePath,true>
    │ │ │ │ -
    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<typename Tree, typename Policy, typename current_type, typename TreePath, typename Tag>
    │ │ │ │ -
    311 struct accumulate_type;
    │ │ │ │ -
    312
    │ │ │ │ -
    314 template<typename LeafNode, typename Policy, typename current_type, typename TreePath>
    │ │ │ │ -
    315 struct accumulate_type<LeafNode,Policy,current_type,TreePath,LeafNodeTag>
    │ │ │ │ -
    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<typename current_type, typename tree_path, typename start_type, typename reduction_strategy>
    │ │ │ │ -
    335 struct propagate_type_down_tree;
    │ │ │ │ -
    336
    │ │ │ │ -
    338 template<typename current_type, typename tree_path, typename start_type>
    │ │ │ │ -
    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<typename current_type, typename tree_path, typename start_type>
    │ │ │ │ -
    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<tree_path>::value == 0,
    │ │ │ │ -
    360 start_type,
    │ │ │ │ -
    361 current_type
    │ │ │ │ -
    362 >::type type;
    │ │ │ │ -
    363 };
    │ │ │ │ -
    364
    │ │ │ │ -
    365
    │ │ │ │ -
    367 template<typename Node, typename Policy, typename current_type, typename TreePath, std::size_t i, std::size_t n>
    │ │ │ │ -
    368 struct accumulate_type_over_children
    │ │ │ │ -
    369 {
    │ │ │ │ -
    370
    │ │ │ │ -
    371 typedef decltype(push_back(TreePath{},index_constant<i>{})) child_tree_path;
    │ │ │ │ -
    372
    │ │ │ │ -
    373 typedef typename Node::template Child<i>::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<child>
    │ │ │ │ -
    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<typename Node, typename Policy, typename current_type, typename TreePath, std::size_t n>
    │ │ │ │ -
    402 struct accumulate_type_over_children<Node,Policy,current_type,TreePath,n,n>
    │ │ │ │ -
    403 {
    │ │ │ │ -
    404
    │ │ │ │ -
    405 typedef current_type type;
    │ │ │ │ -
    406
    │ │ │ │ -
    407 };
    │ │ │ │ -
    408
    │ │ │ │ -
    409
    │ │ │ │ -
    412 template<typename Node, typename Policy, typename current_type, typename TreePath>
    │ │ │ │ -
    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<Node>::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<typename PowerNode, typename Policy, typename current_type, typename TreePath>
    │ │ │ │ -
    441 struct accumulate_type<PowerNode,Policy,current_type,TreePath,PowerNodeTag>
    │ │ │ │ -
    442 : public accumulate_type_generic_composite_node<PowerNode,Policy,current_type,TreePath>
    │ │ │ │ -
    443 {};
    │ │ │ │ -
    444
    │ │ │ │ -
    446 template<typename CompositeNode, typename Policy, typename current_type, typename TreePath>
    │ │ │ │ -
    447 struct accumulate_type<CompositeNode,Policy,current_type,TreePath,CompositeNodeTag>
    │ │ │ │ -
    448 : public accumulate_type_generic_composite_node<CompositeNode,Policy,current_type,TreePath>
    │ │ │ │ -
    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 >
    │ │ │ │ -
    │ │ │ │ -
    468 struct TypeAccumulationPolicy
    │ │ │ │ -
    469 {
    │ │ │ │ -
    470
    │ │ │ │ -
    498 typedef Functor functor;
    │ │ │ │ -
    499
    │ │ │ │ -
    519 typedef Reduction sibling_reduction;
    │ │ │ │ -
    520
    │ │ │ │ -
    527 typedef ParentChildReduction parent_child_reduction;
    │ │ │ │ -
    528
    │ │ │ │ -
    535 typedef StartType start_type;
    │ │ │ │ -
    536
    │ │ │ │ -
    541 typedef ReductionAlgorithm reduction_strategy;
    │ │ │ │ -
    542 };
    │ │ │ │ -
    │ │ │ │ -
    543
    │ │ │ │ -
    544
    │ │ │ │ -
    546
    │ │ │ │ -
    554 template<typename Tree, typename Policy>
    │ │ │ │ -
    │ │ │ │ -
    555 struct AccumulateType
    │ │ │ │ -
    556 {
    │ │ │ │ -
    557
    │ │ │ │ -
    559 typedef typename accumulate_type<
    │ │ │ │ -
    560 Tree,
    │ │ │ │ -
    561 Policy,
    │ │ │ │ -
    562 typename Policy::start_type,
    │ │ │ │ -
    563 HybridTreePath<>,
    │ │ │ │ -
    564 NodeTag<Tree>
    │ │ │ │ -
    565 >::type type;
    │ │ │ │ -
    566
    │ │ │ │ -
    567 };
    │ │ │ │ -
    │ │ │ │ -
    568
    │ │ │ │ -
    569
    │ │ │ │ -
    570
    │ │ │ │ -
    571
    │ │ │ │ -
    572
    │ │ │ │ -
    573 /***************************************************/
    │ │ │ │ -
    574
    │ │ │ │ -
    │ │ │ │ -
    575 namespace Experimental {
    │ │ │ │ -
    576 namespace Impl {
    │ │ │ │ -
    577
    │ │ │ │ -
    579 template<class T, class TreePath, class V, class U,
    │ │ │ │ -
    580 std::enable_if_t<std::decay_t<T>::isLeaf, int> = 0>
    │ │ │ │ -
    581 auto hybridApplyToTree(T&& tree, TreePath treePath, V&& visitor, U&& current_val)
    │ │ │ │ -
    582 {
    │ │ │ │ -
    583 return visitor.leaf(tree, treePath, std::forward<U>(current_val));
    │ │ │ │ -
    584 }
    │ │ │ │ -
    585
    │ │ │ │ -
    587 template<class T, class TreePath, class V, class U,
    │ │ │ │ -
    588 std::enable_if_t<not std::decay_t<T>::isLeaf, int> = 0>
    │ │ │ │ -
    589 auto hybridApplyToTree(T&& tree, TreePath treePath, V&& visitor, U&& current_val)
    │ │ │ │ -
    590 {
    │ │ │ │ -
    591 using Tree = std::remove_reference_t<T>;
    │ │ │ │ -
    592 using Visitor = std::remove_reference_t<V>;
    │ │ │ │ -
    593 auto pre_val = visitor.pre(tree, treePath, std::forward<U>(current_val));
    │ │ │ │ -
    594
    │ │ │ │ -
    595 // check which type of traversal is supported by the tree
    │ │ │ │ -
    596 using allowDynamicTraversal = Dune::Std::is_detected<Detail::DynamicTraversalConcept,Tree>;
    │ │ │ │ -
    597 using allowStaticTraversal = Dune::Std::is_detected<Detail::StaticTraversalConcept,Tree>;
    │ │ │ │ -
    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<Visitor::treePathType == TreePathType::dynamic>;
    │ │ │ │ -
    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&& child = tree.child(i);
    │ │ │ │ -
    608 using Child = std::decay_t<decltype(child)>;
    │ │ │ │ -
    609
    │ │ │ │ -
    610 auto val_before = visitor.beforeChild(tree, child, treePath, 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, treePath, std::move(val_before));}
    │ │ │ │ -
    617 );
    │ │ │ │ -
    618
    │ │ │ │ -
    619 constexpr bool visitChild = Visitor::template VisitChild<Tree,Child,TreePath>::value;
    │ │ │ │ -
    620 auto val_visit = [&](){
    │ │ │ │ -
    621 if constexpr (visitChild) {
    │ │ │ │ -
    622 auto childTreePath = Dune::TypeTree::push_back(treePath, i);
    │ │ │ │ -
    623 return hybridApplyToTree(child, childTreePath, visitor, std::move(val_in));
    │ │ │ │ -
    624 }
    │ │ │ │ -
    625 else
    │ │ │ │ -
    626 return std::move(val_in);
    │ │ │ │ -
    627 }();
    │ │ │ │ -
    628
    │ │ │ │ -
    629 return visitor.afterChild(tree, child, treePath, 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<Tree::degree()>{};
    │ │ │ │ -
    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, treePath, in_val);
    │ │ │ │ -
    673 }
    │ │ │ │ -
    674
    │ │ │ │ -
    675 }
    │ │ │ │ -
    676
    │ │ │ │ -
    700 template<typename Tree, typename Visitor, typename Init>
    │ │ │ │ -
    │ │ │ │ -
    701 auto hybridApplyToTree(Tree&& tree, Visitor&& visitor, Init&& init)
    │ │ │ │ -
    702 {
    │ │ │ │ -
    703 return Impl::hybridApplyToTree(tree, hybridTreePath(), visitor, init);
    │ │ │ │ -
    704 }
    │ │ │ │ -
    │ │ │ │ -
    705
    │ │ │ │ -
    706 } // namespace Experimental
    │ │ │ │ -
    │ │ │ │ -
    707
    │ │ │ │ -
    709 } // namespace TypeTree
    │ │ │ │ -
    │ │ │ │ -
    710} //namespace Dune
    │ │ │ │ -
    │ │ │ │ -
    711
    │ │ │ │ -
    712#endif // DUNE_TYPETREE_ACCUMULATE_STATIC_HH
    │ │ │ │ - │ │ │ │ -
    child_result
    static const result_type child_result
    Definition accumulate_static.hh:156
    │ │ │ │ -
    result
    static const result_type result
    Definition accumulate_static.hh:113
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::Child
    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
    │ │ │ │ -
    Dune::TypeTree::child
    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
    │ │ │ │ -
    Dune::TypeTree::NodeTag
    typename std::decay_t< Node >::NodeTag NodeTag
    Returns the node tag of the given Node.
    Definition nodeinterface.hh:70
    │ │ │ │ -
    Dune::TypeTree::push_back
    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
    │ │ │ │ -
    Dune::TypeTree::hybridTreePath
    constexpr auto hybridTreePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:312
    │ │ │ │ -
    Dune::TypeTree::treePath
    constexpr auto treePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:326
    │ │ │ │ -
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::or_
    Statically combine two values of type result_type using ||.
    Definition accumulate_static.hh:27
    │ │ │ │ -
    Dune::TypeTree::or_::reduce
    Definition accumulate_static.hh:30
    │ │ │ │ -
    Dune::TypeTree::or_::reduce::result
    static const result_type result
    Definition accumulate_static.hh:31
    │ │ │ │ -
    Dune::TypeTree::and_
    Statically combine two values of type result_type using &&.
    Definition accumulate_static.hh:38
    │ │ │ │ -
    Dune::TypeTree::and_::reduce
    Definition accumulate_static.hh:41
    │ │ │ │ -
    Dune::TypeTree::and_::reduce::result
    static const result_type result
    Definition accumulate_static.hh:42
    │ │ │ │ -
    Dune::TypeTree::plus
    Statically combine two values of type result_type using +.
    Definition accumulate_static.hh:49
    │ │ │ │ -
    Dune::TypeTree::plus::reduce
    Definition accumulate_static.hh:52
    │ │ │ │ -
    Dune::TypeTree::plus::reduce::result
    static const result_type result
    Definition accumulate_static.hh:53
    │ │ │ │ -
    Dune::TypeTree::minus
    Statically combine two values of type result_type using -.
    Definition accumulate_static.hh:60
    │ │ │ │ -
    Dune::TypeTree::minus::reduce
    Definition accumulate_static.hh:63
    │ │ │ │ -
    Dune::TypeTree::minus::reduce::result
    static const result_type result
    Definition accumulate_static.hh:64
    │ │ │ │ -
    Dune::TypeTree::multiply
    Statically combine two values of type result_type using *.
    Definition accumulate_static.hh:71
    │ │ │ │ -
    Dune::TypeTree::multiply::reduce
    Definition accumulate_static.hh:74
    │ │ │ │ -
    Dune::TypeTree::multiply::reduce::result
    static const result_type result
    Definition accumulate_static.hh:75
    │ │ │ │ -
    Dune::TypeTree::min
    Statically combine two values of type result_type by returning their minimum.
    Definition accumulate_static.hh:82
    │ │ │ │ -
    Dune::TypeTree::min::reduce
    Definition accumulate_static.hh:85
    │ │ │ │ -
    Dune::TypeTree::min::reduce::result
    static const result_type result
    Definition accumulate_static.hh:86
    │ │ │ │ -
    Dune::TypeTree::max
    Statically combine two values of type result_type by returning their maximum.
    Definition accumulate_static.hh:93
    │ │ │ │ -
    Dune::TypeTree::max::reduce
    Definition accumulate_static.hh:96
    │ │ │ │ -
    Dune::TypeTree::max::reduce::result
    static const result_type result
    Definition accumulate_static.hh:97
    │ │ │ │ -
    Dune::TypeTree::AccumulateValue
    Statically accumulate a value over the nodes of a TypeTree.
    Definition accumulate_static.hh:262
    │ │ │ │ -
    Dune::TypeTree::AccumulateValue::result_type
    Functor::result_type result_type
    The result type of the computation.
    Definition accumulate_static.hh:265
    │ │ │ │ -
    Dune::TypeTree::AccumulateValue::result
    static const result_type result
    The accumulated result of the computation.
    Definition accumulate_static.hh:268
    │ │ │ │ -
    Dune::TypeTree::TypeAccumulationPolicy
    Definition accumulate_static.hh:469
    │ │ │ │ -
    Dune::TypeTree::TypeAccumulationPolicy::parent_child_reduction
    ParentChildReduction parent_child_reduction
    Definition accumulate_static.hh:527
    │ │ │ │ -
    Dune::TypeTree::TypeAccumulationPolicy::functor
    Functor functor
    Definition accumulate_static.hh:498
    │ │ │ │ -
    Dune::TypeTree::TypeAccumulationPolicy::start_type
    StartType start_type
    Definition accumulate_static.hh:535
    │ │ │ │ -
    Dune::TypeTree::TypeAccumulationPolicy::reduction_strategy
    ReductionAlgorithm reduction_strategy
    Definition accumulate_static.hh:541
    │ │ │ │ -
    Dune::TypeTree::TypeAccumulationPolicy::sibling_reduction
    Reduction sibling_reduction
    Definition accumulate_static.hh:519
    │ │ │ │ -
    Dune::TypeTree::AccumulateType
    Statically accumulate a type over the nodes of a TypeTree.
    Definition accumulate_static.hh:556
    │ │ │ │ -
    Dune::TypeTree::AccumulateType::type
    accumulate_type< Tree, Policy, typenamePolicy::start_type, HybridTreePath<>, NodeTag< Tree > >::type type
    The accumulated result of the computation.
    Definition accumulate_static.hh:565
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath
    A hybrid version of TreePath that supports both compile time and run time indices.
    Definition treepath.hh:158
    │ │ │ │ +
    9#include <dune/typetree/nodetags.hh>
    │ │ │ │ +
    10#include <dune/typetree/utility.hh>
    │ │ │ │ +
    11#include <dune/typetree/leafnode.hh>
    │ │ │ │ +
    12#include <dune/typetree/powernode.hh>
    │ │ │ │ +
    13#include <dune/typetree/dynamicpowernode.hh>
    │ │ │ │ +
    14#include <dune/typetree/compositenode.hh>
    │ │ │ │ +
    15#include <dune/typetree/traversal.hh>
    │ │ │ │ +
    16#include <dune/typetree/pairtraversal.hh>
    │ │ │ │ +
    17#include <dune/typetree/traversalutilities.hh>
    │ │ │ │ +
    18#include <dune/typetree/transformation.hh>
    │ │ │ │ +
    19#include <dune/typetree/transformationutilities.hh>
    │ │ │ │ +
    20#include <dune/typetree/accumulate_static.hh>
    │ │ │ │ +
    21#include <dune/typetree/childextraction.hh>
    │ │ │ │ +
    22
    │ │ │ │ +
    23#endif // DUNE_TYPETREE_HH
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,698 +1,48 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -accumulate_static.hh │ │ │ │ │ +typetree.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_HH │ │ │ │ │ +7#define DUNE_TYPETREE_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 │ │ │ │ │ -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 }; │ │ │ │ │ -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 }; │ │ │ │ │ -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 │ │ │ │ │ -_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h │ │ │ │ │ -_c_h_i_l_d___r_e_s_u_l_t │ │ │ │ │ -static const result_type child_result │ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:156 │ │ │ │ │ -_r_e_s_u_l_t │ │ │ │ │ -static const result_type result │ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:113 │ │ │ │ │ -_t_r_e_e_p_a_t_h_._h_h │ │ │ │ │ +9#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ +10#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_u_t_i_l_i_t_y_._h_h> │ │ │ │ │ +11#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_l_e_a_f_n_o_d_e_._h_h> │ │ │ │ │ +12#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_p_o_w_e_r_n_o_d_e_._h_h> │ │ │ │ │ +13#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_d_y_n_a_m_i_c_p_o_w_e_r_n_o_d_e_._h_h> │ │ │ │ │ +14#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_c_o_m_p_o_s_i_t_e_n_o_d_e_._h_h> │ │ │ │ │ +15#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_v_e_r_s_a_l_._h_h> │ │ │ │ │ +16#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_p_a_i_r_t_r_a_v_e_r_s_a_l_._h_h> │ │ │ │ │ +17#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_v_e_r_s_a_l_u_t_i_l_i_t_i_e_s_._h_h> │ │ │ │ │ +18#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_n_s_f_o_r_m_a_t_i_o_n_._h_h> │ │ │ │ │ +19#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_n_s_f_o_r_m_a_t_i_o_n_u_t_i_l_i_t_i_e_s_._h_h> │ │ │ │ │ +20#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_a_c_c_u_m_u_l_a_t_e___s_t_a_t_i_c_._h_h> │ │ │ │ │ +21#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h> │ │ │ │ │ +22 │ │ │ │ │ +23#endif // DUNE_TYPETREE_HH │ │ │ │ │ +_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h │ │ │ │ │ +_p_o_w_e_r_n_o_d_e_._h_h │ │ │ │ │ +_t_r_a_n_s_f_o_r_m_a_t_i_o_n_u_t_i_l_i_t_i_e_s_._h_h │ │ │ │ │ +_a_c_c_u_m_u_l_a_t_e___s_t_a_t_i_c_._h_h │ │ │ │ │ +_d_y_n_a_m_i_c_p_o_w_e_r_n_o_d_e_._h_h │ │ │ │ │ _u_t_i_l_i_t_y_._h_h │ │ │ │ │ +_p_a_i_r_t_r_a_v_e_r_s_a_l_._h_h │ │ │ │ │ +_c_o_m_p_o_s_i_t_e_n_o_d_e_._h_h │ │ │ │ │ _n_o_d_e_t_a_g_s_._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 │ │ │ │ │ -_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 │ │ │ │ │ +_t_r_a_v_e_r_s_a_l_u_t_i_l_i_t_i_e_s_._h_h │ │ │ │ │ +_t_r_a_v_e_r_s_a_l_._h_h │ │ │ │ │ +_l_e_a_f_n_o_d_e_._h_h │ │ │ │ │ +_t_r_a_n_s_f_o_r_m_a_t_i_o_n_._h_h │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00035.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: simpletransformationdescriptors.hh File Reference │ │ │ │ +dune-typetree: utility.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -72,40 +72,33 @@ │ │ │ │
  • dune
  • typetree
    • │ │ │ │
    │ │ │ │
    │ │ │ │
    │ │ │ │
    │ │ │ │ Classes | │ │ │ │ Namespaces
    │ │ │ │ -
    simpletransformationdescriptors.hh File Reference
    │ │ │ │ +
    utility.hh File Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │ -
    #include <array>
    │ │ │ │ -#include <memory>
    │ │ │ │ -#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ -#include <dune/typetree/nodetags.hh>
    │ │ │ │ -#include <dune/common/exceptions.hh>
    │ │ │ │ +
    #include <memory>
    │ │ │ │ +#include <tuple>
    │ │ │ │ +#include <type_traits>
    │ │ │ │ +#include <utility>
    │ │ │ │ +#include <algorithm>
    │ │ │ │ +#include <dune/common/shared_ptr.hh>
    │ │ │ │ +#include <dune/common/indices.hh>
    │ │ │ │ +#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ +#include <dune/typetree/nodetags.hh>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  Dune::TypeTree::SimpleLeafNodeTransformation< SourceNode, Transformation, TransformedNode >
     
    struct  Dune::TypeTree::SimplePowerNodeTransformation< SourceNode, Transformation, TransformedNode >
     
    struct  Dune::TypeTree::SimplePowerNodeTransformation< SourceNode, Transformation, TransformedNode >::result< TC >
     
    struct  Dune::TypeTree::SimpleDynamicPowerNodeTransformation< SourceNode, Transformation, TransformedNode >
     
    struct  Dune::TypeTree::SimpleDynamicPowerNodeTransformation< SourceNode, Transformation, TransformedNode >::result< TC >
     
    struct  Dune::TypeTree::SimpleCompositeNodeTransformation< SourceNode, Transformation, TransformedNode >
     
    struct  Dune::TypeTree::SimpleCompositeNodeTransformation< SourceNode, Transformation, TransformedNode >::result< TC >
    struct  Dune::TypeTree::TreeInfo< Tree, Tag >
     Struct for obtaining some basic structural information about a TypeTree. More...
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,42 +1,29 @@ │ │ │ │ │ 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 │ │ │ │ │ -simpletransformationdescriptors.hh File Reference │ │ │ │ │ -#include │ │ │ │ │ +utility.hh File Reference │ │ │ │ │ #include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#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 │ │ │ │ │ _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_:_:_S_i_m_p_l_e_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ - _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ - _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ - _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _>_:_:_r_e_s_u_l_t_<_ _T_C_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ - _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ - _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _>_:_:_r_e_s_u_l_t_<_ _T_C_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ - _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ - _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _>_:_:_r_e_s_u_l_t_<_ _T_C_ _> │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_I_n_f_o_<_ _T_r_e_e_,_ _T_a_g_ _> │ │ │ │ │ +  Struct for obtaining some basic structural information about 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 │ │ │ │ │   │ │ │ │ │ =============================================================================== │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00035_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: simpletransformationdescriptors.hh Source File │ │ │ │ +dune-typetree: utility.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,209 +74,236 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ -
    simpletransformationdescriptors.hh
    │ │ │ │ +
    utility.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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_SIMPLETRANSFORMATIONDESCRIPTORS_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_SIMPLETRANSFORMATIONDESCRIPTORS_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_UTILITY_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_UTILITY_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <array>
    │ │ │ │ -
    10#include <memory>
    │ │ │ │ -
    11
    │ │ │ │ -
    12#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ -
    13#include <dune/typetree/nodetags.hh>
    │ │ │ │ -
    14#include <dune/common/exceptions.hh>
    │ │ │ │ -
    15
    │ │ │ │ -
    16
    │ │ │ │ -
    17namespace Dune {
    │ │ │ │ -
    18 namespace TypeTree {
    │ │ │ │ +
    9#include <memory>
    │ │ │ │ +
    10#include <tuple>
    │ │ │ │ +
    11#include <type_traits>
    │ │ │ │ +
    12#include <utility>
    │ │ │ │ +
    13#include <algorithm>
    │ │ │ │ +
    14
    │ │ │ │ +
    15#include <dune/common/shared_ptr.hh>
    │ │ │ │ +
    16#include <dune/common/indices.hh>
    │ │ │ │ +
    17#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ +
    18#include <dune/typetree/nodetags.hh>
    │ │ │ │
    19
    │ │ │ │ -
    25 template<typename SourceNode, typename Transformation, typename TransformedNode>
    │ │ │ │ -
    │ │ │ │ -
    26 struct SimpleLeafNodeTransformation
    │ │ │ │ -
    27 {
    │ │ │ │ +
    20namespace Dune {
    │ │ │ │ +
    21 namespace TypeTree {
    │ │ │ │ +
    22
    │ │ │ │ +
    27#ifndef DOXYGEN
    │ │ │ │
    28
    │ │ │ │ -
    29 static const bool recursive = false;
    │ │ │ │ -
    30
    │ │ │ │ -
    31 typedef TransformedNode transformed_type;
    │ │ │ │ -
    32 typedef std::shared_ptr<transformed_type> transformed_storage_type;
    │ │ │ │ -
    33
    │ │ │ │ -
    │ │ │ │ -
    34 static transformed_type transform(const SourceNode& s, const Transformation& t)
    │ │ │ │ -
    35 {
    │ │ │ │ -
    36 return transformed_type();
    │ │ │ │ -
    37 }
    │ │ │ │ -
    │ │ │ │ -
    38
    │ │ │ │ -
    │ │ │ │ -
    39 static transformed_storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t)
    │ │ │ │ -
    40 {
    │ │ │ │ -
    41 return std::make_shared<transformed_type>();
    │ │ │ │ -
    42 }
    │ │ │ │ -
    │ │ │ │ -
    43
    │ │ │ │ -
    44 };
    │ │ │ │ -
    │ │ │ │ -
    45
    │ │ │ │ -
    46
    │ │ │ │ -
    47 template<typename SourceNode, typename Transformation, template<typename Child, std::size_t> class TransformedNode>
    │ │ │ │ -
    │ │ │ │ -
    48 struct SimplePowerNodeTransformation
    │ │ │ │ -
    49 {
    │ │ │ │ -
    50
    │ │ │ │ -
    51 static const bool recursive = true;
    │ │ │ │ -
    52
    │ │ │ │ -
    53 template<typename TC>
    │ │ │ │ -
    │ │ │ │ -
    54 struct result
    │ │ │ │ -
    55 {
    │ │ │ │ -
    56 typedef TransformedNode<TC, StaticDegree<SourceNode>::value> type;
    │ │ │ │ -
    57 typedef std::shared_ptr<type> storage_type;
    │ │ │ │ -
    58 static const std::size_t degree = StaticDegree<type>::value;
    │ │ │ │ -
    59 };
    │ │ │ │ -
    │ │ │ │ -
    60
    │ │ │ │ -
    61 template<typename TC>
    │ │ │ │ -
    │ │ │ │ -
    62 static typename result<TC>::type transform(const SourceNode& s, const Transformation& t, const std::array<std::shared_ptr<TC>,result<TC>::degree>& children)
    │ │ │ │ -
    63 {
    │ │ │ │ -
    64 return typename result<TC>::type(children);
    │ │ │ │ -
    65 }
    │ │ │ │ -
    │ │ │ │ -
    66
    │ │ │ │ -
    67 template<typename TC>
    │ │ │ │ -
    │ │ │ │ -
    68 static typename result<TC>::storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t, const std::array<std::shared_ptr<TC>,result<TC>::degree>& children)
    │ │ │ │ -
    69 {
    │ │ │ │ -
    70 return std::make_shared<typename result<TC>::type>(children);
    │ │ │ │ -
    71 }
    │ │ │ │ -
    │ │ │ │ -
    72
    │ │ │ │ -
    73 };
    │ │ │ │ -
    │ │ │ │ +
    29 template<typename T>
    │ │ │ │ +
    30 std::shared_ptr<T> convert_arg(const T& t)
    │ │ │ │ +
    31 {
    │ │ │ │ +
    32 return std::make_shared<T>(t);
    │ │ │ │ +
    33 }
    │ │ │ │ +
    34
    │ │ │ │ +
    35 template<typename T>
    │ │ │ │ +
    36 std::shared_ptr<T> convert_arg(T& t)
    │ │ │ │ +
    37 {
    │ │ │ │ +
    38 return stackobject_to_shared_ptr(t);
    │ │ │ │ +
    39 }
    │ │ │ │ +
    40
    │ │ │ │ +
    41 template<typename BaseType, typename T>
    │ │ │ │ +
    42 T& assertGridViewType(T& t)
    │ │ │ │ +
    43 {
    │ │ │ │ +
    44 static_assert((std::is_same<typename BaseType::Traits::GridViewType,
    │ │ │ │ +
    45 typename T::Traits::GridViewType>::value),
    │ │ │ │ +
    46 "GridViewType must be equal in all components of composite type");
    │ │ │ │ +
    47 return t;
    │ │ │ │ +
    48 }
    │ │ │ │ +
    49
    │ │ │ │ +
    50 // only bind to real rvalues
    │ │ │ │ +
    51 template<typename T>
    │ │ │ │ +
    52 typename std::enable_if<!std::is_lvalue_reference<T>::value,std::shared_ptr<T> >::type convert_arg(T&& t)
    │ │ │ │ +
    53 {
    │ │ │ │ +
    54 return std::make_shared<T>(std::forward<T>(t));
    │ │ │ │ +
    55 }
    │ │ │ │ +
    56
    │ │ │ │ +
    57
    │ │ │ │ +
    58 namespace Experimental {
    │ │ │ │ +
    59
    │ │ │ │ +
    68 template<class BinaryOp, class Arg>
    │ │ │ │ +
    69 constexpr decltype(auto)
    │ │ │ │ +
    70 left_fold(const BinaryOp& binary_op, Arg&& arg)
    │ │ │ │ +
    71 {
    │ │ │ │ +
    72 return std::forward<Arg>(arg);
    │ │ │ │ +
    73 }
    │ │ │ │
    74
    │ │ │ │ -
    75
    │ │ │ │ -
    76 template<typename SourceNode, typename Transformation, template<typename Child> class TransformedNode>
    │ │ │ │ -
    │ │ │ │ -
    77 struct SimpleDynamicPowerNodeTransformation
    │ │ │ │ -
    78 {
    │ │ │ │ -
    79
    │ │ │ │ -
    80 static const bool recursive = true;
    │ │ │ │ -
    81
    │ │ │ │ -
    82 template<typename TC>
    │ │ │ │ -
    │ │ │ │ -
    83 struct result
    │ │ │ │ -
    84 {
    │ │ │ │ -
    85 typedef TransformedNode<TC> type;
    │ │ │ │ -
    86 typedef std::shared_ptr<type> storage_type;
    │ │ │ │ -
    87 };
    │ │ │ │ -
    │ │ │ │ -
    88
    │ │ │ │ -
    89 template<typename TC>
    │ │ │ │ -
    │ │ │ │ -
    90 static typename result<TC>::type transform(const SourceNode& s, const Transformation& t, const std::vector<std::shared_ptr<TC>>& children)
    │ │ │ │ -
    91 {
    │ │ │ │ -
    92 return typename result<TC>::type(children);
    │ │ │ │ -
    93 }
    │ │ │ │ -
    │ │ │ │ -
    94
    │ │ │ │ -
    95 template<typename TC>
    │ │ │ │ -
    │ │ │ │ -
    96 static typename result<TC>::storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t, const std::vector<std::shared_ptr<TC>>& children)
    │ │ │ │ -
    97 {
    │ │ │ │ -
    98 return std::make_shared<typename result<TC>::type>(children);
    │ │ │ │ -
    99 }
    │ │ │ │ -
    │ │ │ │ -
    100
    │ │ │ │ -
    101 };
    │ │ │ │ -
    │ │ │ │ -
    102
    │ │ │ │ -
    103
    │ │ │ │ -
    104 template<typename SourceNode, typename Transformation, template<typename...> class TransformedNode>
    │ │ │ │ -
    │ │ │ │ -
    105 struct SimpleCompositeNodeTransformation
    │ │ │ │ -
    106 {
    │ │ │ │ +
    96 template<class BinaryOp, class Init, class Arg0, class... Args>
    │ │ │ │ +
    97 constexpr decltype(auto)
    │ │ │ │ +
    98 left_fold(const BinaryOp& binary_op, Init&& init, Arg0&& arg_0, Args&&... args)
    │ │ │ │ +
    99 {
    │ │ │ │ +
    100 return left_fold(
    │ │ │ │ +
    101 binary_op,
    │ │ │ │ +
    102 binary_op(std::forward<Init>(init), std::forward<Arg0>(arg_0)),
    │ │ │ │ +
    103 std::forward<Args>(args)...);
    │ │ │ │ +
    104 }
    │ │ │ │ +
    105
    │ │ │ │ +
    106 } // namespace Experimental
    │ │ │ │
    107
    │ │ │ │ -
    108 static const bool recursive = true;
    │ │ │ │ -
    109
    │ │ │ │ -
    110 template<typename... TC>
    │ │ │ │ -
    │ │ │ │ -
    111 struct result
    │ │ │ │ -
    112 {
    │ │ │ │ -
    113 typedef TransformedNode<TC...> type;
    │ │ │ │ -
    114 typedef std::shared_ptr<type> storage_type;
    │ │ │ │ -
    115 };
    │ │ │ │ -
    │ │ │ │ -
    116
    │ │ │ │ -
    117 template<typename... TC>
    │ │ │ │ -
    │ │ │ │ -
    118 static typename result<TC...>::type transform(const SourceNode& s, const Transformation& t, std::shared_ptr<TC>... children)
    │ │ │ │ -
    119 {
    │ │ │ │ -
    120 return typename result<TC...>::type(children...);
    │ │ │ │ -
    121 }
    │ │ │ │ -
    │ │ │ │ +
    108
    │ │ │ │ +
    109#endif // DOXYGEN
    │ │ │ │ +
    110
    │ │ │ │ +
    112
    │ │ │ │ +
    119 template<typename Tree, typename Tag = StartTag>
    │ │ │ │ +
    │ │ │ │ +
    120 struct TreeInfo
    │ │ │ │ +
    121 {
    │ │ │ │
    122
    │ │ │ │ -
    123 template<typename... TC>
    │ │ │ │ -
    │ │ │ │ -
    124 static typename result<TC...>::storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t, std::shared_ptr<TC>... children)
    │ │ │ │ -
    125 {
    │ │ │ │ -
    126 return std::make_shared<typename result<TC...>::type>(children...);
    │ │ │ │ -
    127 }
    │ │ │ │ -
    │ │ │ │ +
    123 private:
    │ │ │ │ +
    124 // Start the tree traversal
    │ │ │ │ +
    125 typedef TreeInfo<Tree,NodeTag<Tree>> NodeInfo;
    │ │ │ │ +
    126
    │ │ │ │ +
    127 public:
    │ │ │ │
    128
    │ │ │ │ -
    129 };
    │ │ │ │ -
    │ │ │ │ -
    130
    │ │ │ │ -
    132
    │ │ │ │ -
    133 } // namespace TypeTree
    │ │ │ │ -
    134} //namespace Dune
    │ │ │ │ -
    135
    │ │ │ │ -
    136#endif // DUNE_TYPETREE_SIMPLETRANSFORMATIONDESCRIPTORS_HH
    │ │ │ │ - │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::StaticDegree
    decltype(Node::degree()) StaticDegree
    Returns the statically known degree of the given Node type as a std::integral_constant.
    Definition nodeinterface.hh:107
    │ │ │ │ +
    130 static const std::size_t depth = NodeInfo::depth;
    │ │ │ │ +
    131
    │ │ │ │ +
    133 static const std::size_t nodeCount = NodeInfo::nodeCount;
    │ │ │ │ +
    134
    │ │ │ │ +
    136 static const std::size_t leafCount = NodeInfo::leafCount;
    │ │ │ │ +
    137
    │ │ │ │ +
    138 };
    │ │ │ │ +
    │ │ │ │ +
    139
    │ │ │ │ +
    140
    │ │ │ │ +
    141#ifndef DOXYGEN
    │ │ │ │ +
    142
    │ │ │ │ +
    143 // ********************************************************************************
    │ │ │ │ +
    144 // TreeInfo specializations for the different node types
    │ │ │ │ +
    145 // ********************************************************************************
    │ │ │ │ +
    146
    │ │ │ │ +
    147
    │ │ │ │ +
    148 // leaf node
    │ │ │ │ +
    149 template<typename Node>
    │ │ │ │ +
    150 struct TreeInfo<Node,LeafNodeTag>
    │ │ │ │ +
    151 {
    │ │ │ │ +
    152
    │ │ │ │ +
    153 static const std::size_t depth = 1;
    │ │ │ │ +
    154
    │ │ │ │ +
    155 static const std::size_t nodeCount = 1;
    │ │ │ │ +
    156
    │ │ │ │ +
    157 static const std::size_t leafCount = 1;
    │ │ │ │ +
    158
    │ │ │ │ +
    159 };
    │ │ │ │ +
    160
    │ │ │ │ +
    161
    │ │ │ │ +
    162 // power node - exploit the fact that all children are identical
    │ │ │ │ +
    163 template<typename Node>
    │ │ │ │ +
    164 struct TreeInfo<Node,PowerNodeTag>
    │ │ │ │ +
    165 {
    │ │ │ │ +
    166
    │ │ │ │ +
    167 typedef TreeInfo<typename Node::ChildType,NodeTag<typename Node::ChildType>> ChildInfo;
    │ │ │ │ +
    168
    │ │ │ │ +
    169 static const std::size_t depth = 1 + ChildInfo::depth;
    │ │ │ │ +
    170
    │ │ │ │ +
    171 static const std::size_t nodeCount = 1 + StaticDegree<Node>::value * ChildInfo::nodeCount;
    │ │ │ │ +
    172
    │ │ │ │ +
    173 static const std::size_t leafCount = StaticDegree<Node>::value * ChildInfo::leafCount;
    │ │ │ │ +
    174
    │ │ │ │ +
    175 };
    │ │ │ │ +
    176
    │ │ │ │ +
    177
    │ │ │ │ +
    178 namespace {
    │ │ │ │ +
    179
    │ │ │ │ +
    180 // TMP for iterating over the children of a composite node
    │ │ │ │ +
    181 // identical for both composite node implementations
    │ │ │ │ +
    182 template<typename Node, std::size_t k, std::size_t n>
    │ │ │ │ +
    183 struct generic_compositenode_children_info
    │ │ │ │ +
    184 {
    │ │ │ │ +
    185
    │ │ │ │ +
    186 typedef generic_compositenode_children_info<Node,k+1,n> NextChild;
    │ │ │ │ +
    187
    │ │ │ │ +
    188 // extract child info
    │ │ │ │ +
    189 typedef typename Node::template Child<k>::Type Child;
    │ │ │ │ +
    190 typedef NodeTag<Child> ChildTag;
    │ │ │ │ +
    191 typedef TreeInfo<Child,ChildTag> ChildInfo;
    │ │ │ │ +
    192
    │ │ │ │ +
    193 // combine information of current child with info about following children
    │ │ │ │ +
    194 static const std::size_t maxDepth = ChildInfo::depth > NextChild::maxDepth ? ChildInfo::depth : NextChild::maxDepth;
    │ │ │ │ +
    195
    │ │ │ │ +
    196 static const std::size_t nodeCount = ChildInfo::nodeCount + NextChild::nodeCount;
    │ │ │ │ +
    197
    │ │ │ │ +
    198 static const std::size_t leafCount = ChildInfo::leafCount + NextChild::leafCount;
    │ │ │ │ +
    199
    │ │ │ │ +
    200 };
    │ │ │ │ +
    201
    │ │ │ │ +
    202 // End of recursion
    │ │ │ │ +
    203 template<typename Node, std::size_t n>
    │ │ │ │ +
    204 struct generic_compositenode_children_info<Node,n,n>
    │ │ │ │ +
    205 {
    │ │ │ │ +
    206 static const std::size_t maxDepth = 0;
    │ │ │ │ +
    207
    │ │ │ │ +
    208 static const std::size_t nodeCount = 0;
    │ │ │ │ +
    209
    │ │ │ │ +
    210 static const std::size_t leafCount = 0;
    │ │ │ │ +
    211 };
    │ │ │ │ +
    212
    │ │ │ │ +
    213 } // anonymous namespace
    │ │ │ │ +
    214
    │ │ │ │ +
    215
    │ │ │ │ +
    216 // Struct for building information about composite node
    │ │ │ │ +
    217 template<typename Node>
    │ │ │ │ +
    218 struct GenericCompositeNodeInfo
    │ │ │ │ +
    219 {
    │ │ │ │ +
    220
    │ │ │ │ +
    221 typedef generic_compositenode_children_info<Node,0,StaticDegree<Node>::value> Children;
    │ │ │ │ +
    222
    │ │ │ │ +
    223 static const std::size_t depth = 1 + Children::maxDepth;
    │ │ │ │ +
    224
    │ │ │ │ +
    225 static const std::size_t nodeCount = 1 + Children::nodeCount;
    │ │ │ │ +
    226
    │ │ │ │ +
    227 static const std::size_t leafCount = Children::leafCount;
    │ │ │ │ +
    228
    │ │ │ │ +
    229 };
    │ │ │ │ +
    230
    │ │ │ │ +
    231
    │ │ │ │ +
    232 // CompositeNode: delegate to GenericCompositeNodeInfo
    │ │ │ │ +
    233 template<typename Node>
    │ │ │ │ +
    234 struct TreeInfo<Node,CompositeNodeTag>
    │ │ │ │ +
    235 : public GenericCompositeNodeInfo<Node>
    │ │ │ │ +
    236 {};
    │ │ │ │ +
    237
    │ │ │ │ +
    238
    │ │ │ │ +
    239#endif // DOXYGEN
    │ │ │ │ +
    240
    │ │ │ │ +
    241
    │ │ │ │ +
    242 using Dune::index_constant;
    │ │ │ │ +
    243 namespace Indices = Dune::Indices;
    │ │ │ │ +
    244
    │ │ │ │ +
    246
    │ │ │ │ +
    247 } // namespace TypeTree
    │ │ │ │ +
    248} //namespace Dune
    │ │ │ │ +
    249
    │ │ │ │ +
    250#endif // DUNE_TYPETREE_UTILITY_HH
    │ │ │ │ + │ │ │ │ + │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::SimpleLeafNodeTransformation
    Definition simpletransformationdescriptors.hh:27
    │ │ │ │ -
    Dune::TypeTree::SimpleLeafNodeTransformation::transform
    static transformed_type transform(const SourceNode &s, const Transformation &t)
    Definition simpletransformationdescriptors.hh:34
    │ │ │ │ -
    Dune::TypeTree::SimpleLeafNodeTransformation::recursive
    static const bool recursive
    Definition simpletransformationdescriptors.hh:29
    │ │ │ │ -
    Dune::TypeTree::SimpleLeafNodeTransformation::transformed_storage_type
    std::shared_ptr< transformed_type > transformed_storage_type
    Definition simpletransformationdescriptors.hh:32
    │ │ │ │ -
    Dune::TypeTree::SimpleLeafNodeTransformation::transform_storage
    static transformed_storage_type transform_storage(std::shared_ptr< const SourceNode > s, const Transformation &t)
    Definition simpletransformationdescriptors.hh:39
    │ │ │ │ -
    Dune::TypeTree::SimpleLeafNodeTransformation::transformed_type
    TransformedNode transformed_type
    Definition simpletransformationdescriptors.hh:31
    │ │ │ │ -
    Dune::TypeTree::SimplePowerNodeTransformation
    Definition simpletransformationdescriptors.hh:49
    │ │ │ │ -
    Dune::TypeTree::SimplePowerNodeTransformation::transform_storage
    static result< TC >::storage_type transform_storage(std::shared_ptr< const SourceNode > s, const Transformation &t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children)
    Definition simpletransformationdescriptors.hh:68
    │ │ │ │ -
    Dune::TypeTree::SimplePowerNodeTransformation::recursive
    static const bool recursive
    Definition simpletransformationdescriptors.hh:51
    │ │ │ │ -
    Dune::TypeTree::SimplePowerNodeTransformation::transform
    static result< TC >::type transform(const SourceNode &s, const Transformation &t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children)
    Definition simpletransformationdescriptors.hh:62
    │ │ │ │ -
    Dune::TypeTree::SimplePowerNodeTransformation::result
    Definition simpletransformationdescriptors.hh:55
    │ │ │ │ -
    Dune::TypeTree::SimplePowerNodeTransformation::result::type
    TransformedNode< TC, StaticDegree< SourceNode >::value > type
    Definition simpletransformationdescriptors.hh:56
    │ │ │ │ -
    Dune::TypeTree::SimplePowerNodeTransformation::result::degree
    static const std::size_t degree
    Definition simpletransformationdescriptors.hh:58
    │ │ │ │ -
    Dune::TypeTree::SimplePowerNodeTransformation::result::storage_type
    std::shared_ptr< type > storage_type
    Definition simpletransformationdescriptors.hh:57
    │ │ │ │ -
    Dune::TypeTree::SimpleDynamicPowerNodeTransformation
    Definition simpletransformationdescriptors.hh:78
    │ │ │ │ -
    Dune::TypeTree::SimpleDynamicPowerNodeTransformation::recursive
    static const bool recursive
    Definition simpletransformationdescriptors.hh:80
    │ │ │ │ -
    Dune::TypeTree::SimpleDynamicPowerNodeTransformation::transform
    static result< TC >::type transform(const SourceNode &s, const Transformation &t, const std::vector< std::shared_ptr< TC > > &children)
    Definition simpletransformationdescriptors.hh:90
    │ │ │ │ -
    Dune::TypeTree::SimpleDynamicPowerNodeTransformation::transform_storage
    static result< TC >::storage_type transform_storage(std::shared_ptr< const SourceNode > s, const Transformation &t, const std::vector< std::shared_ptr< TC > > &children)
    Definition simpletransformationdescriptors.hh:96
    │ │ │ │ -
    Dune::TypeTree::SimpleDynamicPowerNodeTransformation::result
    Definition simpletransformationdescriptors.hh:84
    │ │ │ │ -
    Dune::TypeTree::SimpleDynamicPowerNodeTransformation::result::type
    TransformedNode< TC > type
    Definition simpletransformationdescriptors.hh:85
    │ │ │ │ -
    Dune::TypeTree::SimpleDynamicPowerNodeTransformation::result::storage_type
    std::shared_ptr< type > storage_type
    Definition simpletransformationdescriptors.hh:86
    │ │ │ │ -
    Dune::TypeTree::SimpleCompositeNodeTransformation
    Definition simpletransformationdescriptors.hh:106
    │ │ │ │ -
    Dune::TypeTree::SimpleCompositeNodeTransformation::recursive
    static const bool recursive
    Definition simpletransformationdescriptors.hh:108
    │ │ │ │ -
    Dune::TypeTree::SimpleCompositeNodeTransformation::transform_storage
    static result< TC... >::storage_type transform_storage(std::shared_ptr< const SourceNode > s, const Transformation &t, std::shared_ptr< TC >... children)
    Definition simpletransformationdescriptors.hh:124
    │ │ │ │ -
    Dune::TypeTree::SimpleCompositeNodeTransformation::transform
    static result< TC... >::type transform(const SourceNode &s, const Transformation &t, std::shared_ptr< TC >... children)
    Definition simpletransformationdescriptors.hh:118
    │ │ │ │ -
    Dune::TypeTree::SimpleCompositeNodeTransformation::result
    Definition simpletransformationdescriptors.hh:112
    │ │ │ │ -
    Dune::TypeTree::SimpleCompositeNodeTransformation::result::storage_type
    std::shared_ptr< type > storage_type
    Definition simpletransformationdescriptors.hh:114
    │ │ │ │ -
    Dune::TypeTree::SimpleCompositeNodeTransformation::result::type
    TransformedNode< TC... > type
    Definition simpletransformationdescriptors.hh:113
    │ │ │ │ +
    Dune::TypeTree::Experimental::Info::leafCount
    auto leafCount(const Tree &tree)
    The number of leaf nodes in the Tree.
    Definition visitor.hh:532
    │ │ │ │ +
    Dune::TypeTree::Experimental::Info::nodeCount
    auto nodeCount(const Tree &tree)
    The total number of nodes in the Tree.
    Definition visitor.hh:524
    │ │ │ │ +
    Dune::TypeTree::Experimental::Info::depth
    auto depth(const Tree &tree)
    The depth of the TypeTree.
    Definition visitor.hh:508
    │ │ │ │ +
    Dune::TypeTree::LeafNodeTag
    Tag designating a leaf node.
    Definition nodetags.hh:18
    │ │ │ │ +
    Dune::TypeTree::TreeInfo
    Struct for obtaining some basic structural information about a TypeTree.
    Definition utility.hh:121
    │ │ │ │ +
    Dune::TypeTree::TreeInfo::leafCount
    static const std::size_t leafCount
    The number of leaf nodes in the TypeTree.
    Definition utility.hh:136
    │ │ │ │ +
    Dune::TypeTree::TreeInfo::depth
    static const std::size_t depth
    The depth of the TypeTree.
    Definition utility.hh:130
    │ │ │ │ +
    Dune::TypeTree::TreeInfo::nodeCount
    static const std::size_t nodeCount
    The total number of nodes in the TypeTree.
    Definition utility.hh:133
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,253 +1,265 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -simpletransformationdescriptors.hh │ │ │ │ │ +utility.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_SIMPLETRANSFORMATIONDESCRIPTORS_HH │ │ │ │ │ -7#define DUNE_TYPETREE_SIMPLETRANSFORMATIONDESCRIPTORS_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_UTILITY_HH │ │ │ │ │ +7#define DUNE_TYPETREE_UTILITY_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include │ │ │ │ │ -10#include │ │ │ │ │ -11 │ │ │ │ │ -12#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> │ │ │ │ │ -13#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ -14#include │ │ │ │ │ -15 │ │ │ │ │ -16 │ │ │ │ │ -17namespace _D_u_n_e { │ │ │ │ │ -18 namespace TypeTree { │ │ │ │ │ +9#include │ │ │ │ │ +10#include │ │ │ │ │ +11#include │ │ │ │ │ +12#include │ │ │ │ │ +13#include │ │ │ │ │ +14 │ │ │ │ │ +15#include │ │ │ │ │ +16#include │ │ │ │ │ +17#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> │ │ │ │ │ +18#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ 19 │ │ │ │ │ -25 template │ │ │ │ │ -_2_6 struct _S_i_m_p_l_e_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -27 { │ │ │ │ │ +20namespace _D_u_n_e { │ │ │ │ │ +21 namespace TypeTree { │ │ │ │ │ +22 │ │ │ │ │ +27#ifndef DOXYGEN │ │ │ │ │ 28 │ │ │ │ │ -_2_9 static const bool _r_e_c_u_r_s_i_v_e = false; │ │ │ │ │ -30 │ │ │ │ │ -_3_1 typedef TransformedNode _t_r_a_n_s_f_o_r_m_e_d___t_y_p_e; │ │ │ │ │ -_3_2 typedef std::shared_ptr _t_r_a_n_s_f_o_r_m_e_d___s_t_o_r_a_g_e___t_y_p_e; │ │ │ │ │ -33 │ │ │ │ │ -_3_4 static _t_r_a_n_s_f_o_r_m_e_d___t_y_p_e _t_r_a_n_s_f_o_r_m(const SourceNode& s, const Transformation& │ │ │ │ │ -t) │ │ │ │ │ -35 { │ │ │ │ │ -36 return _t_r_a_n_s_f_o_r_m_e_d___t_y_p_e(); │ │ │ │ │ -37 } │ │ │ │ │ -38 │ │ │ │ │ -_3_9 static _t_r_a_n_s_f_o_r_m_e_d___s_t_o_r_a_g_e___t_y_p_e _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std::shared_ptr s, const Transformation& t) │ │ │ │ │ -40 { │ │ │ │ │ -41 return std::make_shared(); │ │ │ │ │ -42 } │ │ │ │ │ -43 │ │ │ │ │ -44 }; │ │ │ │ │ -45 │ │ │ │ │ -46 │ │ │ │ │ -47 template class TransformedNode> │ │ │ │ │ -_4_8 struct _S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -49 { │ │ │ │ │ -50 │ │ │ │ │ -_5_1 static const bool _r_e_c_u_r_s_i_v_e = true; │ │ │ │ │ -52 │ │ │ │ │ -53 template │ │ │ │ │ -_5_4 struct _r_e_s_u_l_t │ │ │ │ │ -55 { │ │ │ │ │ -_5_6 typedef TransformedNode::value> _t_y_p_e; │ │ │ │ │ -_5_7 typedef std::shared_ptr _s_t_o_r_a_g_e___t_y_p_e; │ │ │ │ │ -_5_8 static const std::size_t _d_e_g_r_e_e = _S_t_a_t_i_c_D_e_g_r_e_e_<_t_y_p_e_>_:_:_v_a_l_u_e; │ │ │ │ │ -59 }; │ │ │ │ │ -60 │ │ │ │ │ -61 template │ │ │ │ │ -_6_2 static typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e _t_r_a_n_s_f_o_r_m(const SourceNode& s, const │ │ │ │ │ -Transformation& t, const std::array,_r_e_s_u_l_t_<_T_C_>_:_:_d_e_g_r_e_e>& │ │ │ │ │ -children) │ │ │ │ │ -63 { │ │ │ │ │ -64 return typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e(children); │ │ │ │ │ -65 } │ │ │ │ │ -66 │ │ │ │ │ -67 template │ │ │ │ │ -_6_8 static typename _r_e_s_u_l_t_<_T_C_>_:_:_s_t_o_r_a_g_e___t_y_p_e _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std:: │ │ │ │ │ -shared_ptr s, const Transformation& t, const std::array,_r_e_s_u_l_t_<_T_C_>_:_:_d_e_g_r_e_e>& children) │ │ │ │ │ -69 { │ │ │ │ │ -70 return std::make_shared::type>(children); │ │ │ │ │ -71 } │ │ │ │ │ -72 │ │ │ │ │ -73 }; │ │ │ │ │ +29 template │ │ │ │ │ +30 std::shared_ptr convert_arg(const T& t) │ │ │ │ │ +31 { │ │ │ │ │ +32 return std::make_shared(t); │ │ │ │ │ +33 } │ │ │ │ │ +34 │ │ │ │ │ +35 template │ │ │ │ │ +36 std::shared_ptr convert_arg(T& t) │ │ │ │ │ +37 { │ │ │ │ │ +38 return stackobject_to_shared_ptr(t); │ │ │ │ │ +39 } │ │ │ │ │ +40 │ │ │ │ │ +41 template │ │ │ │ │ +42 T& assertGridViewType(T& t) │ │ │ │ │ +43 { │ │ │ │ │ +44 static_assert((std::is_same::value), │ │ │ │ │ +46 "GridViewType must be equal in all components of composite type"); │ │ │ │ │ +47 return t; │ │ │ │ │ +48 } │ │ │ │ │ +49 │ │ │ │ │ +50 // only bind to real rvalues │ │ │ │ │ +51 template │ │ │ │ │ +52 typename std::enable_if::value,std:: │ │ │ │ │ +shared_ptr >::type convert_arg(T&& t) │ │ │ │ │ +53 { │ │ │ │ │ +54 return std::make_shared(std::forward(t)); │ │ │ │ │ +55 } │ │ │ │ │ +56 │ │ │ │ │ +57 │ │ │ │ │ +58 namespace Experimental { │ │ │ │ │ +59 │ │ │ │ │ +68 template │ │ │ │ │ +69 constexpr decltype(auto) │ │ │ │ │ +70 left_fold(const BinaryOp& binary_op, Arg&& arg) │ │ │ │ │ +71 { │ │ │ │ │ +72 return std::forward(arg); │ │ │ │ │ +73 } │ │ │ │ │ 74 │ │ │ │ │ -75 │ │ │ │ │ -76 template class TransformedNode> │ │ │ │ │ -_7_7 struct _S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -78 { │ │ │ │ │ -79 │ │ │ │ │ -_8_0 static const bool _r_e_c_u_r_s_i_v_e = true; │ │ │ │ │ -81 │ │ │ │ │ -82 template │ │ │ │ │ -_8_3 struct _r_e_s_u_l_t │ │ │ │ │ -84 { │ │ │ │ │ -_8_5 typedef TransformedNode _t_y_p_e; │ │ │ │ │ -_8_6 typedef std::shared_ptr _s_t_o_r_a_g_e___t_y_p_e; │ │ │ │ │ -87 }; │ │ │ │ │ -88 │ │ │ │ │ -89 template │ │ │ │ │ -_9_0 static typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e _t_r_a_n_s_f_o_r_m(const SourceNode& s, const │ │ │ │ │ -Transformation& t, const std::vector>& children) │ │ │ │ │ -91 { │ │ │ │ │ -92 return typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e(children); │ │ │ │ │ -93 } │ │ │ │ │ -94 │ │ │ │ │ -95 template │ │ │ │ │ -_9_6 static typename _r_e_s_u_l_t_<_T_C_>_:_:_s_t_o_r_a_g_e___t_y_p_e _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std:: │ │ │ │ │ -shared_ptr s, const Transformation& t, const std:: │ │ │ │ │ -vector>& children) │ │ │ │ │ -97 { │ │ │ │ │ -98 return std::make_shared::type>(children); │ │ │ │ │ -99 } │ │ │ │ │ -100 │ │ │ │ │ -101 }; │ │ │ │ │ -102 │ │ │ │ │ -103 │ │ │ │ │ -104 template class TransformedNode> │ │ │ │ │ -_1_0_5 struct _S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -106 { │ │ │ │ │ +96 template │ │ │ │ │ +97 constexpr decltype(auto) │ │ │ │ │ +98 left_fold(const BinaryOp& binary_op, Init&& init, Arg0&& arg_0, Args&&... │ │ │ │ │ +args) │ │ │ │ │ +99 { │ │ │ │ │ +100 return left_fold( │ │ │ │ │ +101 binary_op, │ │ │ │ │ +102 binary_op(std::forward(init), std::forward(arg_0)), │ │ │ │ │ +103 std::forward(args)...); │ │ │ │ │ +104 } │ │ │ │ │ +105 │ │ │ │ │ +106 } // namespace Experimental │ │ │ │ │ 107 │ │ │ │ │ -_1_0_8 static const bool _r_e_c_u_r_s_i_v_e = true; │ │ │ │ │ -109 │ │ │ │ │ -110 template │ │ │ │ │ -_1_1_1 struct _r_e_s_u_l_t │ │ │ │ │ -112 { │ │ │ │ │ -_1_1_3 typedef TransformedNode _t_y_p_e; │ │ │ │ │ -_1_1_4 typedef std::shared_ptr _s_t_o_r_a_g_e___t_y_p_e; │ │ │ │ │ -115 }; │ │ │ │ │ -116 │ │ │ │ │ -117 template │ │ │ │ │ -_1_1_8 static typename _r_e_s_u_l_t::type _t_r_a_n_s_f_o_r_m(const SourceNode& s, const │ │ │ │ │ -Transformation& t, std::shared_ptr... children) │ │ │ │ │ -119 { │ │ │ │ │ -120 return typename _r_e_s_u_l_t_<_T_C_._._._>_:_:_t_y_p_e(children...); │ │ │ │ │ -121 } │ │ │ │ │ +108 │ │ │ │ │ +109#endif // DOXYGEN │ │ │ │ │ +110 │ │ │ │ │ +112 │ │ │ │ │ +119 template │ │ │ │ │ +_1_2_0 struct _T_r_e_e_I_n_f_o │ │ │ │ │ +121 { │ │ │ │ │ 122 │ │ │ │ │ -123 template │ │ │ │ │ -_1_2_4 static typename _r_e_s_u_l_t::storage_type _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std:: │ │ │ │ │ -shared_ptr s, const Transformation& t, std::shared_ptr... │ │ │ │ │ -children) │ │ │ │ │ -125 { │ │ │ │ │ -126 return std::make_shared::type>(children...); │ │ │ │ │ -127 } │ │ │ │ │ +123 private: │ │ │ │ │ +124 // Start the tree traversal │ │ │ │ │ +125 typedef _T_r_e_e_I_n_f_o_<_T_r_e_e_,_N_o_d_e_T_a_g_<_T_r_e_e_>> _N_o_d_e_I_n_f_o; │ │ │ │ │ +126 │ │ │ │ │ +127 public: │ │ │ │ │ 128 │ │ │ │ │ -129 }; │ │ │ │ │ -130 │ │ │ │ │ -132 │ │ │ │ │ -133 } // namespace TypeTree │ │ │ │ │ -134} //namespace Dune │ │ │ │ │ -135 │ │ │ │ │ -136#endif // DUNE_TYPETREE_SIMPLETRANSFORMATIONDESCRIPTORS_HH │ │ │ │ │ -_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h │ │ │ │ │ +_1_3_0 static const std::size_t _d_e_p_t_h = _N_o_d_e_I_n_f_o_:_:_d_e_p_t_h; │ │ │ │ │ +131 │ │ │ │ │ +_1_3_3 static const std::size_t _n_o_d_e_C_o_u_n_t = _N_o_d_e_I_n_f_o_:_:_n_o_d_e_C_o_u_n_t; │ │ │ │ │ +134 │ │ │ │ │ +_1_3_6 static const std::size_t _l_e_a_f_C_o_u_n_t = _N_o_d_e_I_n_f_o_:_:_l_e_a_f_C_o_u_n_t; │ │ │ │ │ +137 │ │ │ │ │ +138 }; │ │ │ │ │ +139 │ │ │ │ │ +140 │ │ │ │ │ +141#ifndef DOXYGEN │ │ │ │ │ +142 │ │ │ │ │ +143 / │ │ │ │ │ +/ │ │ │ │ │ +******************************************************************************** │ │ │ │ │ +144 // TreeInfo specializations for the different node types │ │ │ │ │ +145 / │ │ │ │ │ +/ │ │ │ │ │ +******************************************************************************** │ │ │ │ │ +146 │ │ │ │ │ +147 │ │ │ │ │ +148 // leaf node │ │ │ │ │ +149 template │ │ │ │ │ +150 struct _T_r_e_e_I_n_f_o │ │ │ │ │ +151 { │ │ │ │ │ +152 │ │ │ │ │ +153 static const std::size_t _d_e_p_t_h = 1; │ │ │ │ │ +154 │ │ │ │ │ +155 static const std::size_t _n_o_d_e_C_o_u_n_t = 1; │ │ │ │ │ +156 │ │ │ │ │ +157 static const std::size_t _l_e_a_f_C_o_u_n_t = 1; │ │ │ │ │ +158 │ │ │ │ │ +159 }; │ │ │ │ │ +160 │ │ │ │ │ +161 │ │ │ │ │ +162 // power node - exploit the fact that all children are identical │ │ │ │ │ +163 template │ │ │ │ │ +164 struct TreeInfo │ │ │ │ │ +165 { │ │ │ │ │ +166 │ │ │ │ │ +167 typedef TreeInfo> ChildInfo; │ │ │ │ │ +168 │ │ │ │ │ +169 static const std::size_t _d_e_p_t_h = 1 + ChildInfo::depth; │ │ │ │ │ +170 │ │ │ │ │ +171 static const std::size_t _n_o_d_e_C_o_u_n_t = 1 + StaticDegree::value * │ │ │ │ │ +ChildInfo::nodeCount; │ │ │ │ │ +172 │ │ │ │ │ +173 static const std::size_t _l_e_a_f_C_o_u_n_t = StaticDegree::value * │ │ │ │ │ +ChildInfo::leafCount; │ │ │ │ │ +174 │ │ │ │ │ +175 }; │ │ │ │ │ +176 │ │ │ │ │ +177 │ │ │ │ │ +178 namespace { │ │ │ │ │ +179 │ │ │ │ │ +180 // TMP for iterating over the children of a composite node │ │ │ │ │ +181 // identical for both composite node implementations │ │ │ │ │ +182 template │ │ │ │ │ +183 struct generic_compositenode_children_info │ │ │ │ │ +184 { │ │ │ │ │ +185 │ │ │ │ │ +186 typedef generic_compositenode_children_info NextChild; │ │ │ │ │ +187 │ │ │ │ │ +188 // extract child info │ │ │ │ │ +189 typedef typename Node::template Child::Type Child; │ │ │ │ │ +190 typedef NodeTag ChildTag; │ │ │ │ │ +191 typedef TreeInfo ChildInfo; │ │ │ │ │ +192 │ │ │ │ │ +193 // combine information of current child with info about following children │ │ │ │ │ +194 static const std::size_t maxDepth = ChildInfo::depth > NextChild::maxDepth │ │ │ │ │ +? ChildInfo::depth : NextChild::maxDepth; │ │ │ │ │ +195 │ │ │ │ │ +196 static const std::size_t nodeCount = ChildInfo::nodeCount + NextChild:: │ │ │ │ │ +nodeCount; │ │ │ │ │ +197 │ │ │ │ │ +198 static const std::size_t leafCount = ChildInfo::leafCount + NextChild:: │ │ │ │ │ +leafCount; │ │ │ │ │ +199 │ │ │ │ │ +200 }; │ │ │ │ │ +201 │ │ │ │ │ +202 // End of recursion │ │ │ │ │ +203 template │ │ │ │ │ +204 struct generic_compositenode_children_info │ │ │ │ │ +205 { │ │ │ │ │ +206 static const std::size_t maxDepth = 0; │ │ │ │ │ +207 │ │ │ │ │ +208 static const std::size_t _n_o_d_e_C_o_u_n_t = 0; │ │ │ │ │ +209 │ │ │ │ │ +210 static const std::size_t _l_e_a_f_C_o_u_n_t = 0; │ │ │ │ │ +211 }; │ │ │ │ │ +212 │ │ │ │ │ +213 } // anonymous namespace │ │ │ │ │ +214 │ │ │ │ │ +215 │ │ │ │ │ +216 // Struct for building information about composite node │ │ │ │ │ +217 template │ │ │ │ │ +218 struct GenericCompositeNodeInfo │ │ │ │ │ +219 { │ │ │ │ │ +220 │ │ │ │ │ +221 typedef generic_compositenode_children_info:: │ │ │ │ │ +value> Children; │ │ │ │ │ +222 │ │ │ │ │ +223 static const std::size_t _d_e_p_t_h = 1 + Children::maxDepth; │ │ │ │ │ +224 │ │ │ │ │ +225 static const std::size_t _n_o_d_e_C_o_u_n_t = 1 + Children::nodeCount; │ │ │ │ │ +226 │ │ │ │ │ +227 static const std::size_t _l_e_a_f_C_o_u_n_t = Children::leafCount; │ │ │ │ │ +228 │ │ │ │ │ +229 }; │ │ │ │ │ +230 │ │ │ │ │ +231 │ │ │ │ │ +232 // CompositeNode: delegate to GenericCompositeNodeInfo │ │ │ │ │ +233 template │ │ │ │ │ +234 struct TreeInfo │ │ │ │ │ +235 : public GenericCompositeNodeInfo │ │ │ │ │ +236 {}; │ │ │ │ │ +237 │ │ │ │ │ +238 │ │ │ │ │ +239#endif // DOXYGEN │ │ │ │ │ +240 │ │ │ │ │ +241 │ │ │ │ │ +242 using Dune::index_constant; │ │ │ │ │ +243 namespace Indices = Dune::Indices; │ │ │ │ │ +244 │ │ │ │ │ +246 │ │ │ │ │ +247 } // namespace TypeTree │ │ │ │ │ +248} //namespace Dune │ │ │ │ │ +249 │ │ │ │ │ +250#endif // DUNE_TYPETREE_UTILITY_HH │ │ │ │ │ _n_o_d_e_t_a_g_s_._h_h │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_D_e_g_r_e_e │ │ │ │ │ -decltype(Node::degree()) StaticDegree │ │ │ │ │ -Returns the statically known degree of the given Node type as a std:: │ │ │ │ │ -integral_constant. │ │ │ │ │ -DDeeffiinniittiioonn nodeinterface.hh:107 │ │ │ │ │ +_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h │ │ │ │ │ _D_u_n_e │ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:27 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ -static transformed_type transform(const SourceNode &s, const Transformation &t) │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:34 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_c_u_r_s_i_v_e │ │ │ │ │ -static const bool recursive │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:29 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m_e_d___s_t_o_r_a_g_e___t_y_p_e │ │ │ │ │ -std::shared_ptr< transformed_type > transformed_storage_type │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:32 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ -static transformed_storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ -SourceNode > s, const Transformation &t) │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:39 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m_e_d___t_y_p_e │ │ │ │ │ -TransformedNode transformed_type │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:31 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:49 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ -static result< TC >::storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ -SourceNode > s, const Transformation &t, const std::array< std::shared_ptr< TC │ │ │ │ │ ->, result< TC >::degree > &children) │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:68 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_c_u_r_s_i_v_e │ │ │ │ │ -static const bool recursive │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:51 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ -static result< TC >::type transform(const SourceNode &s, const Transformation │ │ │ │ │ -&t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children) │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:62 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:55 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_t_y_p_e │ │ │ │ │ -TransformedNode< TC, StaticDegree< SourceNode >::value > type │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:56 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_d_e_g_r_e_e │ │ │ │ │ -static const std::size_t degree │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:58 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_s_t_o_r_a_g_e___t_y_p_e │ │ │ │ │ -std::shared_ptr< type > storage_type │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:57 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:78 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_c_u_r_s_i_v_e │ │ │ │ │ -static const bool recursive │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:80 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ -static result< TC >::type transform(const SourceNode &s, const Transformation │ │ │ │ │ -&t, const std::vector< std::shared_ptr< TC > > &children) │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:90 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ -static result< TC >::storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ -SourceNode > s, const Transformation &t, const std::vector< std::shared_ptr< TC │ │ │ │ │ -> > &children) │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:96 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:84 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_t_y_p_e │ │ │ │ │ -TransformedNode< TC > type │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:85 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_s_t_o_r_a_g_e___t_y_p_e │ │ │ │ │ -std::shared_ptr< type > storage_type │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:86 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:106 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_c_u_r_s_i_v_e │ │ │ │ │ -static const bool recursive │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:108 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ -static result< TC... >::storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ -SourceNode > s, const Transformation &t, std::shared_ptr< TC >... children) │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:124 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ -static result< TC... >::type transform(const SourceNode &s, const │ │ │ │ │ -Transformation &t, std::shared_ptr< TC >... children) │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:118 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:112 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_s_t_o_r_a_g_e___t_y_p_e │ │ │ │ │ -std::shared_ptr< type > storage_type │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:114 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_t_y_p_e │ │ │ │ │ -TransformedNode< TC... > type │ │ │ │ │ -DDeeffiinniittiioonn simpletransformationdescriptors.hh:113 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_l_e_a_f_C_o_u_n_t │ │ │ │ │ +auto leafCount(const Tree &tree) │ │ │ │ │ +The number of leaf nodes in the Tree. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:532 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_n_o_d_e_C_o_u_n_t │ │ │ │ │ +auto nodeCount(const Tree &tree) │ │ │ │ │ +The total number of nodes in the Tree. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:524 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_d_e_p_t_h │ │ │ │ │ +auto depth(const Tree &tree) │ │ │ │ │ +The depth of the TypeTree. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:508 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e_T_a_g │ │ │ │ │ +Tag designating a leaf node. │ │ │ │ │ +DDeeffiinniittiioonn nodetags.hh:18 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_I_n_f_o │ │ │ │ │ +Struct for obtaining some basic structural information about a TypeTree. │ │ │ │ │ +DDeeffiinniittiioonn utility.hh:121 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_I_n_f_o_:_:_l_e_a_f_C_o_u_n_t │ │ │ │ │ +static const std::size_t leafCount │ │ │ │ │ +The number of leaf nodes in the TypeTree. │ │ │ │ │ +DDeeffiinniittiioonn utility.hh:136 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_I_n_f_o_:_:_d_e_p_t_h │ │ │ │ │ +static const std::size_t depth │ │ │ │ │ +The depth of the TypeTree. │ │ │ │ │ +DDeeffiinniittiioonn utility.hh:130 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_I_n_f_o_:_:_n_o_d_e_C_o_u_n_t │ │ │ │ │ +static const std::size_t nodeCount │ │ │ │ │ +The total number of nodes in the TypeTree. │ │ │ │ │ +DDeeffiinniittiioonn utility.hh:133 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00038.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: powernode.hh File Reference │ │ │ │ +dune-typetree: pairtraversal.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -70,47 +70,46 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -Classes | │ │ │ │ -Namespaces
    │ │ │ │ -
    powernode.hh File Reference
    │ │ │ │ +Namespaces | │ │ │ │ +Functions
    │ │ │ │ +
    pairtraversal.hh File Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ -
    #include <cassert>
    │ │ │ │ -#include <array>
    │ │ │ │ -#include <memory>
    │ │ │ │ -#include <type_traits>
    │ │ │ │ -#include <dune/common/typetraits.hh>
    │ │ │ │ -#include <dune/common/std/type_traits.hh>
    │ │ │ │ -#include <dune/typetree/nodetags.hh>
    │ │ │ │ -#include <dune/typetree/utility.hh>
    │ │ │ │ -#include <dune/typetree/childextraction.hh>
    │ │ │ │ -#include <dune/typetree/typetraits.hh>
    │ │ │ │ +
    #include <dune/common/std/type_traits.hh>
    │ │ │ │ +#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ +#include <dune/typetree/nodetags.hh>
    │ │ │ │ +#include <dune/typetree/treepath.hh>
    │ │ │ │ +#include <dune/typetree/visitor.hh>
    │ │ │ │ +#include <dune/typetree/traversal.hh>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -

    │ │ │ │ -Classes

    class  Dune::TypeTree::PowerNode< T, k >
     Collect k instances of type T within a dune-typetree. More...
     
    struct  Dune::TypeTree::PowerNode< T, k >::Child< i >
     Access to the type and storage type of the i-th child. More...
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + │ │ │ │ + │ │ │ │ +

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
     
    namespace  Dune::TypeTree::Detail
     
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │

    │ │ │ │ +Functions

    template<class T1 , class T2 , class TreePath , class V , std::enable_if_t<(std::decay_t< T1 >::isLeaf or std::decay_t< T2 >::isLeaf), int > = 0>
    void Dune::TypeTree::Detail::applyToTreePair (T1 &&tree1, T2 &&tree2, TreePath treePath, V &&visitor)
     
    template<typename Tree1 , typename Tree2 , typename Visitor >
    void Dune::TypeTree::applyToTreePair (Tree1 &&tree1, Tree2 &&tree2, Visitor &&visitor)
     Apply visitor to a pair of TypeTrees.
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,33 +1,35 @@ │ │ │ │ │ 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 │ │ │ │ │ -powernode.hh File Reference │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ +_N_a_m_e_s_p_a_c_e_s | _F_u_n_c_t_i_o_n_s │ │ │ │ │ +pairtraversal.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_/_u_t_i_l_i_t_y_._h_h> │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h> │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_y_p_e_t_r_a_i_t_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_/_v_i_s_i_t_o_r_._h_h> │ │ │ │ │ +#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 │ │ │ │ │ - class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_<_ _T_,_ _k_ _> │ │ │ │ │ -  Collect k instances of type T within a _d_u_n_e_-_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_:_:_P_o_w_e_r_N_o_d_e_<_ _T_,_ _k_ _>_:_:_C_h_i_l_d_<_ _i_ _> │ │ │ │ │ -  Access to the type and storage type of the i-th child. _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_:_:_D_e_t_a_i_l │ │ │ │ │ +  │ │ │ │ │ +FFuunnccttiioonnss │ │ │ │ │ +template::isLeaf or std::decay_t< T2 >::isLeaf), int > = 0> │ │ │ │ │ +void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_a_p_p_l_y_T_o_T_r_e_e_P_a_i_r (T1 &&tree1, T2 &&tree2, TreePath │ │ │ │ │ + _t_r_e_e_P_a_t_h, V &&visitor) │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ +void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_p_p_l_y_T_o_T_r_e_e_P_a_i_r (Tree1 &&tree1, Tree2 &&tree2, Visitor │ │ │ │ │ + &&visitor) │ │ │ │ │ +  Apply visitor to a pair of TypeTrees. │ │ │ │ │ +  │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00038_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: powernode.hh Source File │ │ │ │ +dune-typetree: pairtraversal.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,401 +74,152 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -
    powernode.hh
    │ │ │ │ +
    pairtraversal.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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_POWERNODE_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_POWERNODE_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_PAIRTRAVERSAL_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_PAIRTRAVERSAL_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <cassert>
    │ │ │ │ -
    10#include <array>
    │ │ │ │ -
    11#include <memory>
    │ │ │ │ -
    12#include <type_traits>
    │ │ │ │ -
    13
    │ │ │ │ -
    14#include <dune/common/typetraits.hh>
    │ │ │ │ -
    15#include <dune/common/std/type_traits.hh>
    │ │ │ │ +
    9#include <dune/common/std/type_traits.hh>
    │ │ │ │ +
    10
    │ │ │ │ +
    11#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ +
    12#include <dune/typetree/nodetags.hh>
    │ │ │ │ +
    13#include <dune/typetree/treepath.hh>
    │ │ │ │ +
    14#include <dune/typetree/visitor.hh>
    │ │ │ │ +
    15#include <dune/typetree/traversal.hh>
    │ │ │ │
    16
    │ │ │ │ -
    17#include <dune/typetree/nodetags.hh>
    │ │ │ │ -
    18#include <dune/typetree/utility.hh>
    │ │ │ │ -
    19#include <dune/typetree/childextraction.hh>
    │ │ │ │ -
    20#include <dune/typetree/typetraits.hh>
    │ │ │ │ -
    21
    │ │ │ │ -
    22namespace Dune {
    │ │ │ │ -
    23 namespace TypeTree {
    │ │ │ │ -
    24
    │ │ │ │ -
    31#ifndef DOXYGEN
    │ │ │ │ -
    32
    │ │ │ │ -
    34 template<typename PowerNode, typename T, std::size_t k>
    │ │ │ │ -
    35 struct AssertPowerNodeChildCount
    │ │ │ │ -
    36 : public std::enable_if<std::is_same<
    │ │ │ │ -
    37 typename PowerNode::ChildType,
    │ │ │ │ -
    38 T>::value &&
    │ │ │ │ -
    39 PowerNode::degree() == k,
    │ │ │ │ -
    40 T>
    │ │ │ │ -
    41 {};
    │ │ │ │ -
    42
    │ │ │ │ -
    43#endif
    │ │ │ │ +
    17namespace Dune {
    │ │ │ │ +
    18 namespace TypeTree {
    │ │ │ │ +
    19
    │ │ │ │ +
    │ │ │ │ +
    25 namespace Detail {
    │ │ │ │ +
    26
    │ │ │ │ +
    27 /* The signature is the same as for the public applyToTreePair
    │ │ │ │ +
    28 * function in Dune::Typtree, despite the additionally passed
    │ │ │ │ +
    29 * treePath argument. The path passed here is associated to
    │ │ │ │ +
    30 * the tree and the relative paths of the children (wrt. to tree)
    │ │ │ │ +
    31 * are appended to this. Hence the behavior of the public function
    │ │ │ │ +
    32 * is resembled by passing an empty treePath.
    │ │ │ │ +
    33 */
    │ │ │ │ +
    34
    │ │ │ │ +
    35 /*
    │ │ │ │ +
    36 * This is the overload for leaf traversal
    │ │ │ │ +
    37 */
    │ │ │ │ +
    38 template<class T1, class T2, class TreePath, class V,
    │ │ │ │ +
    39 std::enable_if_t<(std::decay_t<T1>::isLeaf or std::decay_t<T2>::isLeaf), int> = 0>
    │ │ │ │ +
    │ │ │ │ +
    40 void applyToTreePair(T1&& tree1, T2&& tree2, TreePath treePath, V&& visitor)
    │ │ │ │ +
    41 {
    │ │ │ │ +
    42 visitor.leaf(tree1, tree2, treePath);
    │ │ │ │ +
    43 }
    │ │ │ │ +
    │ │ │ │
    44
    │ │ │ │ -
    50 template<typename T, std::size_t k>
    │ │ │ │ -
    │ │ │ │ -
    51 class PowerNode
    │ │ │ │ -
    52 {
    │ │ │ │ -
    53
    │ │ │ │ -
    54 public:
    │ │ │ │ -
    55
    │ │ │ │ -
    57 static const bool isLeaf = false;
    │ │ │ │ -
    58
    │ │ │ │ -
    60 static const bool isPower = true;
    │ │ │ │ +
    45 /*
    │ │ │ │ +
    46 * This is the general overload doing static child traversal.
    │ │ │ │ +
    47 */
    │ │ │ │ +
    48 template<class T1, class T2, class TreePath, class V,
    │ │ │ │ +
    49 std::enable_if_t<not(std::decay_t<T1>::isLeaf or std::decay_t<T2>::isLeaf), int> = 0>
    │ │ │ │ +
    50 void applyToTreePair(T1&& tree1, T2&& tree2, TreePath treePath, V&& visitor)
    │ │ │ │ +
    51 {
    │ │ │ │ +
    52 // Do we really want to take care for const-ness of the Tree
    │ │ │ │ +
    53 // when instanciating VisitChild below? I'd rather expect this:
    │ │ │ │ +
    54 // using Tree1 = std::decay_t<T1>;
    │ │ │ │ +
    55 // using Tree2 = std::decay_t<T2>;
    │ │ │ │ +
    56 // using Visitor = std::decay_t<V>;
    │ │ │ │ +
    57 using Tree1 = std::remove_reference_t<T1>;
    │ │ │ │ +
    58 using Tree2 = std::remove_reference_t<T2>;
    │ │ │ │ +
    59 using Visitor = std::remove_reference_t<V>;
    │ │ │ │ +
    60 visitor.pre(tree1, tree2, treePath);
    │ │ │ │
    61
    │ │ │ │ -
    63 static const bool isComposite = false;
    │ │ │ │ -
    64
    │ │ │ │ -
    │ │ │ │ -
    65 static constexpr auto degree ()
    │ │ │ │ -
    66 {
    │ │ │ │ -
    67 return std::integral_constant<std::size_t,k>{};
    │ │ │ │ -
    68 }
    │ │ │ │ -
    │ │ │ │ +
    62 // check which type of traversal is supported by the trees
    │ │ │ │ +
    63 using allowDynamicTraversal = std::conjunction<
    │ │ │ │ +
    64 Dune::Std::is_detected<DynamicTraversalConcept,Tree1>,
    │ │ │ │ +
    65 Dune::Std::is_detected<DynamicTraversalConcept,Tree2>>;
    │ │ │ │ +
    66 using allowStaticTraversal = std::conjunction<
    │ │ │ │ +
    67 Dune::Std::is_detected<StaticTraversalConcept,Tree1>,
    │ │ │ │ +
    68 Dune::Std::is_detected<StaticTraversalConcept,Tree2>>;
    │ │ │ │
    69
    │ │ │ │ -
    71 typedef PowerNodeTag NodeTag;
    │ │ │ │ +
    70 // both trees must support either dynamic or static traversal
    │ │ │ │ +
    71 static_assert(allowDynamicTraversal::value || allowStaticTraversal::value);
    │ │ │ │
    72
    │ │ │ │ -
    74 typedef T ChildType;
    │ │ │ │ +
    73 // the visitor may specify preferred dynamic traversal
    │ │ │ │ +
    74 using preferDynamicTraversal = std::bool_constant<Visitor::treePathType == TreePathType::dynamic>;
    │ │ │ │
    75
    │ │ │ │ -
    77 typedef std::array<std::shared_ptr<T>,k> NodeStorage;
    │ │ │ │ -
    78
    │ │ │ │ -
    79
    │ │ │ │ -
    81 template<std::size_t i>
    │ │ │ │ -
    │ │ │ │ -
    82 struct Child
    │ │ │ │ -
    83 {
    │ │ │ │ -
    84
    │ │ │ │ -
    85 static_assert((i < degree()), "child index out of range");
    │ │ │ │ -
    86
    │ │ │ │ -
    88 typedef T Type;
    │ │ │ │ -
    89
    │ │ │ │ -
    91 typedef T type;
    │ │ │ │ -
    92 };
    │ │ │ │ -
    │ │ │ │ -
    93
    │ │ │ │ -
    96
    │ │ │ │ -
    98
    │ │ │ │ -
    101 template<std::size_t i>
    │ │ │ │ -
    │ │ │ │ -
    102 T& child (index_constant<i> = {})
    │ │ │ │ -
    103 {
    │ │ │ │ -
    104 static_assert((i < degree()), "child index out of range");
    │ │ │ │ -
    105 return *_children[i];
    │ │ │ │ -
    106 }
    │ │ │ │ -
    │ │ │ │ -
    107
    │ │ │ │ +
    76 // create a dynamic or static index range
    │ │ │ │ +
    77 auto indices = [&]{
    │ │ │ │ +
    78 if constexpr(preferDynamicTraversal::value && allowDynamicTraversal::value)
    │ │ │ │ +
    79 return Dune::range(std::size_t(tree1.degree()));
    │ │ │ │ +
    80 else
    │ │ │ │ +
    81 return Dune::range(tree1.degree());
    │ │ │ │ +
    82 }();
    │ │ │ │ +
    83
    │ │ │ │ +
    84 if constexpr(allowDynamicTraversal::value || allowStaticTraversal::value) {
    │ │ │ │ +
    85 Dune::Hybrid::forEach(indices, [&](auto i) {
    │ │ │ │ +
    86 auto&& child1 = tree1.child(i);
    │ │ │ │ +
    87 auto&& child2 = tree2.child(i);
    │ │ │ │ +
    88 using Child1 = std::decay_t<decltype(child1)>;
    │ │ │ │ +
    89 using Child2 = std::decay_t<decltype(child2)>;
    │ │ │ │ +
    90
    │ │ │ │ +
    91 visitor.beforeChild(tree1, child1, tree2, child2, treePath, i);
    │ │ │ │ +
    92
    │ │ │ │ +
    93 // This requires that visitor.in(...) can always be instantiated,
    │ │ │ │ +
    94 // even if there's a single child only.
    │ │ │ │ +
    95 if (i>0)
    │ │ │ │ +
    96 visitor.in(tree1, tree2, treePath);
    │ │ │ │ +
    97
    │ │ │ │ +
    98 constexpr bool visitChild = Visitor::template VisitChild<Tree1,Child1,Tree2,Child2,TreePath>::value;
    │ │ │ │ +
    99 if constexpr(visitChild) {
    │ │ │ │ +
    100 auto childTreePath = Dune::TypeTree::push_back(treePath, i);
    │ │ │ │ +
    101 applyToTreePair(child1, child2, childTreePath, visitor);
    │ │ │ │ +
    102 }
    │ │ │ │ +
    103
    │ │ │ │ +
    104 visitor.afterChild(tree1, child1, tree2, child2, treePath, i);
    │ │ │ │ +
    105 });
    │ │ │ │ +
    106 }
    │ │ │ │ +
    107 visitor.post(tree1, tree2, treePath);
    │ │ │ │ +
    108 }
    │ │ │ │
    109
    │ │ │ │ -
    112 template<std::size_t i>
    │ │ │ │ -
    │ │ │ │ -
    113 const T& child (index_constant<i> = {}) const
    │ │ │ │ -
    114 {
    │ │ │ │ -
    115 static_assert((i < degree()), "child index out of range");
    │ │ │ │ -
    116 return *_children[i];
    │ │ │ │ -
    117 }
    │ │ │ │ -
    │ │ │ │ -
    118
    │ │ │ │ -
    120
    │ │ │ │ -
    123 template<std::size_t i>
    │ │ │ │ -
    │ │ │ │ -
    124 std::shared_ptr<T> childStorage (index_constant<i> = {})
    │ │ │ │ -
    125 {
    │ │ │ │ -
    126 static_assert((i < degree()), "child index out of range");
    │ │ │ │ -
    127 return _children[i];
    │ │ │ │ -
    128 }
    │ │ │ │ -
    │ │ │ │ -
    129
    │ │ │ │ -
    131
    │ │ │ │ -
    134 template<std::size_t i>
    │ │ │ │ -
    │ │ │ │ -
    135 std::shared_ptr<const T> childStorage (index_constant<i> = {}) const
    │ │ │ │ -
    136 {
    │ │ │ │ -
    137 static_assert((i < degree()), "child index out of range");
    │ │ │ │ -
    138 return _children[i];
    │ │ │ │ -
    139 }
    │ │ │ │ -
    │ │ │ │ -
    140
    │ │ │ │ -
    142 template<std::size_t i>
    │ │ │ │ -
    │ │ │ │ -
    143 void setChild (T& t, index_constant<i> = {})
    │ │ │ │ -
    144 {
    │ │ │ │ -
    145 static_assert((i < degree()), "child index out of range");
    │ │ │ │ -
    146 _children[i] = stackobject_to_shared_ptr(t);
    │ │ │ │ -
    147 }
    │ │ │ │ -
    │ │ │ │ -
    148
    │ │ │ │ -
    150 template<std::size_t i>
    │ │ │ │ -
    │ │ │ │ -
    151 void setChild (T&& t, index_constant<i> = {})
    │ │ │ │ -
    152 {
    │ │ │ │ -
    153 static_assert((i < degree()), "child index out of range");
    │ │ │ │ -
    154 _children[i] = convert_arg(std::move(t));
    │ │ │ │ -
    155 }
    │ │ │ │ -
    │ │ │ │ -
    156
    │ │ │ │ -
    158 template<std::size_t i>
    │ │ │ │ -
    │ │ │ │ -
    159 void setChild (std::shared_ptr<T> st, index_constant<i> = {})
    │ │ │ │ -
    160 {
    │ │ │ │ -
    161 static_assert((i < degree()), "child index out of range");
    │ │ │ │ -
    162 _children[i] = std::move(st);
    │ │ │ │ -
    163 }
    │ │ │ │ -
    │ │ │ │ -
    164
    │ │ │ │ -
    166
    │ │ │ │ -
    167
    │ │ │ │ -
    170
    │ │ │ │ -
    172
    │ │ │ │ -
    │ │ │ │ -
    175 T& child (std::size_t i)
    │ │ │ │ -
    176 {
    │ │ │ │ -
    177 assert(i < degree() && "child index out of range");
    │ │ │ │ -
    178 return *_children[i];
    │ │ │ │ -
    179 }
    │ │ │ │ -
    │ │ │ │ -
    180
    │ │ │ │ -
    182
    │ │ │ │ -
    │ │ │ │ -
    185 const T& child (std::size_t i) const
    │ │ │ │ -
    186 {
    │ │ │ │ -
    187 assert(i < degree() && "child index out of range");
    │ │ │ │ -
    188 return *_children[i];
    │ │ │ │ -
    189 }
    │ │ │ │ -
    │ │ │ │ -
    190
    │ │ │ │ -
    192
    │ │ │ │ -
    │ │ │ │ -
    195 std::shared_ptr<T> childStorage (std::size_t i)
    │ │ │ │ -
    196 {
    │ │ │ │ -
    197 assert(i < degree() && "child index out of range");
    │ │ │ │ -
    198 return _children[i];
    │ │ │ │ -
    199 }
    │ │ │ │ -
    │ │ │ │ -
    200
    │ │ │ │ -
    202
    │ │ │ │ -
    │ │ │ │ -
    205 std::shared_ptr<const T> childStorage (std::size_t i) const
    │ │ │ │ -
    206 {
    │ │ │ │ -
    207 assert(i < degree() && "child index out of range");
    │ │ │ │ -
    208 return _children[i];
    │ │ │ │ -
    209 }
    │ │ │ │ -
    │ │ │ │ -
    210
    │ │ │ │ -
    │ │ │ │ -
    212 void setChild (std::size_t i, T& t)
    │ │ │ │ -
    213 {
    │ │ │ │ -
    214 assert(i < degree() && "child index out of range");
    │ │ │ │ -
    215 _children[i] = stackobject_to_shared_ptr(t);
    │ │ │ │ -
    216 }
    │ │ │ │ -
    │ │ │ │ -
    217
    │ │ │ │ -
    │ │ │ │ -
    219 void setChild (std::size_t i, T&& t)
    │ │ │ │ -
    220 {
    │ │ │ │ -
    221 assert(i < degree() && "child index out of range");
    │ │ │ │ -
    222 _children[i] = convert_arg(std::move(t));
    │ │ │ │ -
    223 }
    │ │ │ │ -
    │ │ │ │ -
    224
    │ │ │ │ -
    │ │ │ │ -
    226 void setChild (std::size_t i, std::shared_ptr<T> st)
    │ │ │ │ -
    227 {
    │ │ │ │ -
    228 assert(i < degree() && "child index out of range");
    │ │ │ │ -
    229 _children[i] = std::move(st);
    │ │ │ │ -
    230 }
    │ │ │ │ -
    │ │ │ │ -
    231
    │ │ │ │ -
    │ │ │ │ -
    232 const NodeStorage& nodeStorage () const
    │ │ │ │ -
    233 {
    │ │ │ │ -
    234 return _children;
    │ │ │ │ -
    235 }
    │ │ │ │ -
    │ │ │ │ -
    236
    │ │ │ │ -
    238
    │ │ │ │ -
    241
    │ │ │ │ -
    242 // The following two methods require a little bit of SFINAE trickery to work correctly:
    │ │ │ │ -
    243 // We have to make sure that they don't shadow the methods for direct child access because
    │ │ │ │ -
    244 // those get called by the generic child() machinery. If that machinery picks up the methods
    │ │ │ │ -
    245 // defined below, we have an infinite recursion.
    │ │ │ │ -
    246 // So the methods make sure that either
    │ │ │ │ -
    247 //
    │ │ │ │ -
    248 // * there are more than one argument. In that case, we got multiple indices and can forward
    │ │ │ │ -
    249 // to the general machine.
    │ │ │ │ -
    250 //
    │ │ │ │ -
    251 // * the first argument is not a valid flat index, i.e. either a std::size_t or an index_constant.
    │ │ │ │ -
    252 // The argument thus has to be some kind of TreePath instance that we can also pass to the
    │ │ │ │ -
    253 // generic machine.
    │ │ │ │ -
    254 //
    │ │ │ │ -
    255 // The above SFINAE logic works, but there is still a problem with the return type deduction.
    │ │ │ │ -
    256 // We have to do a lazy lookup of the return type after SFINAE has succeeded, otherwise the return
    │ │ │ │ -
    257 // type deduction will trigger the infinite recursion.
    │ │ │ │ -
    258
    │ │ │ │ -
    260
    │ │ │ │ -
    264#ifdef DOXYGEN
    │ │ │ │ -
    265 template<typename... Indices>
    │ │ │ │ -
    │ │ │ │ -
    266 ImplementationDefined& child (Indices... indices)
    │ │ │ │ -
    267#else
    │ │ │ │ -
    268 template<typename I0, typename... I,
    │ │ │ │ -
    269 std::enable_if_t<(sizeof...(I) > 0) || IsTreePath<I0>::value, int > = 0>
    │ │ │ │ -
    270 decltype(auto) child (I0 i0, I... i)
    │ │ │ │ -
    271#endif
    │ │ │ │ -
    272 {
    │ │ │ │ -
    273 static_assert(sizeof...(I) > 0 || impl::_non_empty_tree_path(I0{}),
    │ │ │ │ -
    274 "You cannot use the member function child() with an empty TreePath, use the freestanding version child(node,treePath) instead."
    │ │ │ │ -
    275 );
    │ │ │ │ -
    276 return Dune::TypeTree::child(*this,i0,i...);
    │ │ │ │ -
    277 }
    │ │ │ │ -
    │ │ │ │ -
    278
    │ │ │ │ -
    280
    │ │ │ │ -
    284#ifdef DOXYGEN
    │ │ │ │ -
    285 template<typename... Indices>
    │ │ │ │ -
    │ │ │ │ -
    286 const ImplementationDefined& child (Indices... indices)
    │ │ │ │ -
    287#else
    │ │ │ │ -
    288 template<typename I0, typename... I,
    │ │ │ │ -
    289 std::enable_if_t<(sizeof...(I) > 0) || IsTreePath<I0>::value, int > = 0>
    │ │ │ │ -
    290 decltype(auto) child (I0 i0, I... i) const
    │ │ │ │ -
    291#endif
    │ │ │ │ -
    292 {
    │ │ │ │ -
    293 static_assert(sizeof...(I) > 0 || impl::_non_empty_tree_path(I0{}),
    │ │ │ │ -
    294 "You cannot use the member function child() with an empty TreePath, use the freestanding version child(node,treePath) instead."
    │ │ │ │ -
    295 );
    │ │ │ │ -
    296 return Dune::TypeTree::child(*this,i0,i...);
    │ │ │ │ -
    297 }
    │ │ │ │ -
    │ │ │ │ -
    298
    │ │ │ │ -
    300
    │ │ │ │ -
    303
    │ │ │ │ -
    304 protected:
    │ │ │ │ -
    305
    │ │ │ │ -
    307
    │ │ │ │ -
    │ │ │ │ -
    315 PowerNode ()
    │ │ │ │ -
    316 {}
    │ │ │ │ -
    │ │ │ │ -
    317
    │ │ │ │ -
    │ │ │ │ -
    319 explicit PowerNode (const NodeStorage& children)
    │ │ │ │ -
    320 : _children(children)
    │ │ │ │ -
    321 {}
    │ │ │ │ -
    │ │ │ │ -
    322
    │ │ │ │ -
    │ │ │ │ -
    324 explicit PowerNode (T& t, bool distinct_objects = true)
    │ │ │ │ -
    325 {
    │ │ │ │ -
    326 if (distinct_objects)
    │ │ │ │ -
    327 {
    │ │ │ │ -
    328 for (typename NodeStorage::iterator it = _children.begin(); it != _children.end(); ++it)
    │ │ │ │ -
    329 *it = std::make_shared<T>(t);
    │ │ │ │ -
    330 }
    │ │ │ │ -
    331 else
    │ │ │ │ -
    332 {
    │ │ │ │ -
    333 std::shared_ptr<T> sp = stackobject_to_shared_ptr(t);
    │ │ │ │ -
    334 std::fill(_children.begin(),_children.end(),sp);
    │ │ │ │ -
    335 }
    │ │ │ │ -
    336 }
    │ │ │ │ -
    │ │ │ │ -
    337
    │ │ │ │ -
    338#ifdef DOXYGEN
    │ │ │ │ -
    339
    │ │ │ │ -
    │ │ │ │ -
    341 PowerNode(T& t1, T& t2, ...)
    │ │ │ │ -
    342 {}
    │ │ │ │ -
    │ │ │ │ -
    343
    │ │ │ │ -
    344#else
    │ │ │ │ -
    345
    │ │ │ │ -
    346 template<typename... Children,
    │ │ │ │ -
    347 std::enable_if_t<
    │ │ │ │ -
    348 std::conjunction<std::is_same<ChildType, std::decay_t<Children>>...>::value
    │ │ │ │ -
    349 ,int> = 0>
    │ │ │ │ -
    350 PowerNode (Children&&... children)
    │ │ │ │ -
    351 {
    │ │ │ │ -
    352 static_assert(degree() == sizeof...(Children), "PowerNode constructor is called with incorrect number of children");
    │ │ │ │ -
    353 _children = NodeStorage{convert_arg(std::forward<Children>(children))...};
    │ │ │ │ -
    354 }
    │ │ │ │ -
    355
    │ │ │ │ -
    356 template<typename... Children,
    │ │ │ │ -
    357 std::enable_if_t<
    │ │ │ │ -
    358 std::conjunction<std::is_same<ChildType, Children>...>::value
    │ │ │ │ -
    359 ,int> = 0>
    │ │ │ │ -
    360 PowerNode (std::shared_ptr<Children>... children)
    │ │ │ │ -
    361 {
    │ │ │ │ -
    362 static_assert(degree() == sizeof...(Children), "PowerNode constructor is called with incorrect number of children");
    │ │ │ │ -
    363 _children = NodeStorage{children...};
    │ │ │ │ -
    364 }
    │ │ │ │ -
    365
    │ │ │ │ -
    366#endif // DOXYGEN
    │ │ │ │ -
    367
    │ │ │ │ -
    369
    │ │ │ │ -
    370 private:
    │ │ │ │ -
    371 NodeStorage _children;
    │ │ │ │ -
    372 };
    │ │ │ │ +
    110 } // namespace Detail
    │ │ │ │
    │ │ │ │ -
    373
    │ │ │ │ -
    375
    │ │ │ │ -
    376 } // namespace TypeTree
    │ │ │ │ -
    377} //namespace Dune
    │ │ │ │ -
    378
    │ │ │ │ -
    379#endif // DUNE_TYPETREE_POWERNODE_HH
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::child
    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
    │ │ │ │ +
    111
    │ │ │ │ +
    113
    │ │ │ │ +
    127 template<typename Tree1, typename Tree2, typename Visitor>
    │ │ │ │ +
    │ │ │ │ +
    128 void applyToTreePair(Tree1&& tree1, Tree2&& tree2, Visitor&& visitor)
    │ │ │ │ +
    129 {
    │ │ │ │ +
    130 Detail::applyToTreePair(tree1, tree2, hybridTreePath(), visitor);
    │ │ │ │ +
    131 }
    │ │ │ │ +
    │ │ │ │ +
    132
    │ │ │ │ +
    134
    │ │ │ │ +
    135 } // namespace TypeTree
    │ │ │ │ +
    136} //namespace Dune
    │ │ │ │ +
    137
    │ │ │ │ +
    138#endif // DUNE_TYPETREE_PAIRTRAVERSAL_HH
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::applyToTreePair
    void applyToTreePair(Tree1 &&tree1, Tree2 &&tree2, Visitor &&visitor)
    Apply visitor to a pair of TypeTrees.
    Definition pairtraversal.hh:128
    │ │ │ │ +
    Dune::TypeTree::push_back
    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
    │ │ │ │ +
    Dune::TypeTree::hybridTreePath
    constexpr auto hybridTreePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:312
    │ │ │ │ +
    Dune::TypeTree::treePath
    constexpr auto treePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:326
    │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::PowerNodeTag
    Tag designating a power node.
    Definition nodetags.hh:21
    │ │ │ │ -
    Dune::TypeTree::PowerNode
    Collect k instances of type T within a dune-typetree.
    Definition powernode.hh:52
    │ │ │ │ -
    Dune::TypeTree::PowerNode::setChild
    void setChild(T &t, index_constant< i >={})
    Sets the i-th child to the passed-in value.
    Definition powernode.hh:143
    │ │ │ │ -
    Dune::TypeTree::PowerNode::child
    T & child(std::size_t i)
    Returns the i-th child.
    Definition powernode.hh:175
    │ │ │ │ -
    Dune::TypeTree::PowerNode::child
    const T & child(index_constant< i >={}) const
    Returns the i-th child (const version).
    Definition powernode.hh:113
    │ │ │ │ -
    Dune::TypeTree::PowerNode::setChild
    void setChild(std::shared_ptr< T > st, index_constant< i >={})
    Sets the stored value representing the i-th child to the passed-in value.
    Definition powernode.hh:159
    │ │ │ │ -
    Dune::TypeTree::PowerNode::childStorage
    std::shared_ptr< T > childStorage(index_constant< i >={})
    Returns the storage of the i-th child.
    Definition powernode.hh:124
    │ │ │ │ -
    Dune::TypeTree::PowerNode::PowerNode
    PowerNode(T &t1, T &t2,...)
    Initialize all children with the passed-in objects.
    Definition powernode.hh:341
    │ │ │ │ -
    Dune::TypeTree::PowerNode::nodeStorage
    const NodeStorage & nodeStorage() const
    Definition powernode.hh:232
    │ │ │ │ -
    Dune::TypeTree::PowerNode::NodeStorage
    std::array< std::shared_ptr< T >, k > NodeStorage
    The type used for storing the children.
    Definition powernode.hh:77
    │ │ │ │ -
    Dune::TypeTree::PowerNode::childStorage
    std::shared_ptr< const T > childStorage(index_constant< i >={}) const
    Returns the storage of the i-th child (const version).
    Definition powernode.hh:135
    │ │ │ │ -
    Dune::TypeTree::PowerNode::PowerNode
    PowerNode(T &t, bool distinct_objects=true)
    Initialize all children with copies of a storage object constructed from the parameter t.
    Definition powernode.hh:324
    │ │ │ │ -
    Dune::TypeTree::PowerNode::NodeTag
    PowerNodeTag NodeTag
    The type tag that describes a PowerNode.
    Definition powernode.hh:71
    │ │ │ │ -
    Dune::TypeTree::PowerNode::child
    const T & child(std::size_t i) const
    Returns the i-th child (const version).
    Definition powernode.hh:185
    │ │ │ │ -
    Dune::TypeTree::PowerNode::degree
    static constexpr auto degree()
    Definition powernode.hh:65
    │ │ │ │ -
    Dune::TypeTree::PowerNode::childStorage
    std::shared_ptr< const T > childStorage(std::size_t i) const
    Returns the storage of the i-th child (const version).
    Definition powernode.hh:205
    │ │ │ │ -
    Dune::TypeTree::PowerNode::setChild
    void setChild(std::size_t i, std::shared_ptr< T > st)
    Sets the stored value representing the i-th child to the passed-in value.
    Definition powernode.hh:226
    │ │ │ │ -
    Dune::TypeTree::PowerNode::isComposite
    static const bool isComposite
    Mark this class as a non composite in the dune-typetree.
    Definition powernode.hh:63
    │ │ │ │ -
    Dune::TypeTree::PowerNode::isLeaf
    static const bool isLeaf
    Mark this class as non leaf in the dune-typetree.
    Definition powernode.hh:57
    │ │ │ │ -
    Dune::TypeTree::PowerNode::isPower
    static const bool isPower
    Mark this class as a power in the dune-typetree.
    Definition powernode.hh:60
    │ │ │ │ -
    Dune::TypeTree::PowerNode::PowerNode
    PowerNode(const NodeStorage &children)
    Initialize the PowerNode with a copy of the passed-in storage type.
    Definition powernode.hh:319
    │ │ │ │ -
    Dune::TypeTree::PowerNode::ChildType
    T ChildType
    The type of each child.
    Definition powernode.hh:74
    │ │ │ │ -
    Dune::TypeTree::PowerNode::child
    T & child(index_constant< i >={})
    Returns the i-th child.
    Definition powernode.hh:102
    │ │ │ │ -
    Dune::TypeTree::PowerNode::child
    ImplementationDefined & child(Indices... indices)
    Returns the child given by the list of indices.
    Definition powernode.hh:266
    │ │ │ │ -
    Dune::TypeTree::PowerNode::setChild
    void setChild(std::size_t i, T &&t)
    Store the passed value in i-th child.
    Definition powernode.hh:219
    │ │ │ │ -
    Dune::TypeTree::PowerNode::setChild
    void setChild(T &&t, index_constant< i >={})
    Store the passed value in i-th child.
    Definition powernode.hh:151
    │ │ │ │ -
    Dune::TypeTree::PowerNode::PowerNode
    PowerNode()
    Default constructor.
    Definition powernode.hh:315
    │ │ │ │ -
    Dune::TypeTree::PowerNode::child
    const ImplementationDefined & child(Indices... indices)
    Returns the child given by the list of indices.
    Definition powernode.hh:286
    │ │ │ │ -
    Dune::TypeTree::PowerNode::setChild
    void setChild(std::size_t i, T &t)
    Sets the i-th child to the passed-in value.
    Definition powernode.hh:212
    │ │ │ │ -
    Dune::TypeTree::PowerNode::childStorage
    std::shared_ptr< T > childStorage(std::size_t i)
    Returns the storage of the i-th child.
    Definition powernode.hh:195
    │ │ │ │ -
    Dune::TypeTree::PowerNode::Child
    Access to the type and storage type of the i-th child.
    Definition powernode.hh:83
    │ │ │ │ -
    Dune::TypeTree::PowerNode::Child::type
    T type
    The type of the child.
    Definition powernode.hh:91
    │ │ │ │ -
    Dune::TypeTree::PowerNode::Child::Type
    T Type
    The type of the child.
    Definition powernode.hh:88
    │ │ │ │ -
    Dune::TypeTree::IsTreePath
    Check if type represents a tree path.
    Definition typetraits.hh:184
    │ │ │ │ +
    Dune::TypeTree::Detail::applyToTreePair
    void applyToTreePair(T1 &&tree1, T2 &&tree2, TreePath treePath, V &&visitor)
    Definition pairtraversal.hh:40
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,463 +1,161 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -powernode.hh │ │ │ │ │ +pairtraversal.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_POWERNODE_HH │ │ │ │ │ -7#define DUNE_TYPETREE_POWERNODE_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_PAIRTRAVERSAL_HH │ │ │ │ │ +7#define DUNE_TYPETREE_PAIRTRAVERSAL_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include │ │ │ │ │ -10#include │ │ │ │ │ -11#include │ │ │ │ │ -12#include │ │ │ │ │ -13 │ │ │ │ │ -14#include │ │ │ │ │ -15#include │ │ │ │ │ +9#include │ │ │ │ │ +10 │ │ │ │ │ +11#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> │ │ │ │ │ +12#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ +13#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_e_e_p_a_t_h_._h_h> │ │ │ │ │ +14#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_v_i_s_i_t_o_r_._h_h> │ │ │ │ │ +15#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_v_e_r_s_a_l_._h_h> │ │ │ │ │ 16 │ │ │ │ │ -17#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ -18#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_u_t_i_l_i_t_y_._h_h> │ │ │ │ │ -19#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h> │ │ │ │ │ -20#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_y_p_e_t_r_a_i_t_s_._h_h> │ │ │ │ │ -21 │ │ │ │ │ -22namespace _D_u_n_e { │ │ │ │ │ -23 namespace TypeTree { │ │ │ │ │ -24 │ │ │ │ │ -31#ifndef DOXYGEN │ │ │ │ │ -32 │ │ │ │ │ -34 template │ │ │ │ │ -35 struct AssertPowerNodeChildCount │ │ │ │ │ -36 : public std::enable_if::value && │ │ │ │ │ -39 PowerNode::degree() == k, │ │ │ │ │ -40 T> │ │ │ │ │ -41 {}; │ │ │ │ │ -42 │ │ │ │ │ -43#endif │ │ │ │ │ +17namespace _D_u_n_e { │ │ │ │ │ +18 namespace TypeTree { │ │ │ │ │ +19 │ │ │ │ │ +_2_5 namespace Detail { │ │ │ │ │ +26 │ │ │ │ │ +27 /* The signature is the same as for the public applyToTreePair │ │ │ │ │ +28 * function in Dune::Typtree, despite the additionally passed │ │ │ │ │ +29 * treePath argument. The path passed here is associated to │ │ │ │ │ +30 * the tree and the relative paths of the children (wrt. to tree) │ │ │ │ │ +31 * are appended to this. Hence the behavior of the public function │ │ │ │ │ +32 * is resembled by passing an empty treePath. │ │ │ │ │ +33 */ │ │ │ │ │ +34 │ │ │ │ │ +35 /* │ │ │ │ │ +36 * This is the overload for leaf traversal │ │ │ │ │ +37 */ │ │ │ │ │ +38 template::isLeaf or std::decay_t::isLeaf), │ │ │ │ │ +int> = 0> │ │ │ │ │ +_4_0 void _a_p_p_l_y_T_o_T_r_e_e_P_a_i_r(T1&& tree1, T2&& tree2, TreePath _t_r_e_e_P_a_t_h, V&& visitor) │ │ │ │ │ +41 { │ │ │ │ │ +42 visitor.leaf(tree1, tree2, _t_r_e_e_P_a_t_h); │ │ │ │ │ +43 } │ │ │ │ │ 44 │ │ │ │ │ -50 template │ │ │ │ │ -_5_1 class _P_o_w_e_r_N_o_d_e │ │ │ │ │ -52 { │ │ │ │ │ -53 │ │ │ │ │ -54 public: │ │ │ │ │ -55 │ │ │ │ │ -_5_7 static const bool _i_s_L_e_a_f = false; │ │ │ │ │ -58 │ │ │ │ │ -_6_0 static const bool _i_s_P_o_w_e_r = true; │ │ │ │ │ +45 /* │ │ │ │ │ +46 * This is the general overload doing static child traversal. │ │ │ │ │ +47 */ │ │ │ │ │ +48 template::isLeaf or std::decay_t::isLeaf), │ │ │ │ │ +int> = 0> │ │ │ │ │ +50 void _a_p_p_l_y_T_o_T_r_e_e_P_a_i_r(T1&& tree1, T2&& tree2, TreePath _t_r_e_e_P_a_t_h, V&& visitor) │ │ │ │ │ +51 { │ │ │ │ │ +52 // Do we really want to take care for const-ness of the Tree │ │ │ │ │ +53 // when instanciating VisitChild below? I'd rather expect this: │ │ │ │ │ +54 // using Tree1 = std::decay_t; │ │ │ │ │ +55 // using Tree2 = std::decay_t; │ │ │ │ │ +56 // using Visitor = std::decay_t; │ │ │ │ │ +57 using Tree1 = std::remove_reference_t; │ │ │ │ │ +58 using Tree2 = std::remove_reference_t; │ │ │ │ │ +59 using Visitor = std::remove_reference_t; │ │ │ │ │ +60 visitor.pre(tree1, tree2, _t_r_e_e_P_a_t_h); │ │ │ │ │ 61 │ │ │ │ │ -_6_3 static const bool _i_s_C_o_m_p_o_s_i_t_e = false; │ │ │ │ │ -64 │ │ │ │ │ -_6_5 static constexpr auto _d_e_g_r_e_e () │ │ │ │ │ -66 { │ │ │ │ │ -67 return std::integral_constant{}; │ │ │ │ │ -68 } │ │ │ │ │ +62 // check which type of traversal is supported by the trees │ │ │ │ │ +63 using allowDynamicTraversal = std::conjunction< │ │ │ │ │ +64 Dune::Std::is_detected, │ │ │ │ │ +65 Dune::Std::is_detected>; │ │ │ │ │ +66 using allowStaticTraversal = std::conjunction< │ │ │ │ │ +67 Dune::Std::is_detected, │ │ │ │ │ +68 Dune::Std::is_detected>; │ │ │ │ │ 69 │ │ │ │ │ -_7_1 typedef _P_o_w_e_r_N_o_d_e_T_a_g _N_o_d_e_T_a_g; │ │ │ │ │ +70 // both trees must support either dynamic or static traversal │ │ │ │ │ +71 static_assert(allowDynamicTraversal::value || allowStaticTraversal::value); │ │ │ │ │ 72 │ │ │ │ │ -_7_4 typedef T _C_h_i_l_d_T_y_p_e; │ │ │ │ │ +73 // the visitor may specify preferred dynamic traversal │ │ │ │ │ +74 using preferDynamicTraversal = std::bool_constant; │ │ │ │ │ 75 │ │ │ │ │ -_7_7 typedef std::array,k> _N_o_d_e_S_t_o_r_a_g_e; │ │ │ │ │ -78 │ │ │ │ │ -79 │ │ │ │ │ -81 template │ │ │ │ │ -_8_2 struct _C_h_i_l_d │ │ │ │ │ -83 { │ │ │ │ │ -84 │ │ │ │ │ -85 static_assert((i < _d_e_g_r_e_e()), "child index out of range"); │ │ │ │ │ -86 │ │ │ │ │ -_8_8 typedef T _T_y_p_e; │ │ │ │ │ -89 │ │ │ │ │ -_9_1 typedef T _t_y_p_e; │ │ │ │ │ -92 }; │ │ │ │ │ -93 │ │ │ │ │ -96 │ │ │ │ │ -98 │ │ │ │ │ -101 template │ │ │ │ │ -_1_0_2 T& _c_h_i_l_d (index_constant = {}) │ │ │ │ │ -103 { │ │ │ │ │ -104 static_assert((i < _d_e_g_r_e_e()), "child index out of range"); │ │ │ │ │ -105 return *_children[i]; │ │ │ │ │ +76 // create a dynamic or static index range │ │ │ │ │ +77 auto indices = [&]{ │ │ │ │ │ +78 if constexpr(preferDynamicTraversal::value && allowDynamicTraversal::value) │ │ │ │ │ +79 return Dune::range(std::size_t(tree1.degree())); │ │ │ │ │ +80 else │ │ │ │ │ +81 return Dune::range(tree1.degree()); │ │ │ │ │ +82 }(); │ │ │ │ │ +83 │ │ │ │ │ +84 if constexpr(allowDynamicTraversal::value || allowStaticTraversal::value) { │ │ │ │ │ +85 Dune::Hybrid::forEach(indices, [&](auto i) { │ │ │ │ │ +86 auto&& child1 = tree1.child(i); │ │ │ │ │ +87 auto&& child2 = tree2.child(i); │ │ │ │ │ +88 using Child1 = std::decay_t; │ │ │ │ │ +89 using Child2 = std::decay_t; │ │ │ │ │ +90 │ │ │ │ │ +91 visitor.beforeChild(tree1, child1, tree2, child2, _t_r_e_e_P_a_t_h, i); │ │ │ │ │ +92 │ │ │ │ │ +93 // This requires that visitor.in(...) can always be instantiated, │ │ │ │ │ +94 // even if there's a single child only. │ │ │ │ │ +95 if (i>0) │ │ │ │ │ +96 visitor.in(tree1, tree2, _t_r_e_e_P_a_t_h); │ │ │ │ │ +97 │ │ │ │ │ +98 constexpr bool visitChild = Visitor::template │ │ │ │ │ +VisitChild::value; │ │ │ │ │ +99 if constexpr(visitChild) { │ │ │ │ │ +100 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); │ │ │ │ │ +101 _a_p_p_l_y_T_o_T_r_e_e_P_a_i_r(child1, child2, childTreePath, visitor); │ │ │ │ │ +102 } │ │ │ │ │ +103 │ │ │ │ │ +104 visitor.afterChild(tree1, child1, tree2, child2, _t_r_e_e_P_a_t_h, i); │ │ │ │ │ +105 }); │ │ │ │ │ 106 } │ │ │ │ │ -107 │ │ │ │ │ +107 visitor.post(tree1, tree2, _t_r_e_e_P_a_t_h); │ │ │ │ │ +108 } │ │ │ │ │ 109 │ │ │ │ │ -112 template │ │ │ │ │ -_1_1_3 const T& _c_h_i_l_d (index_constant = {}) const │ │ │ │ │ -114 { │ │ │ │ │ -115 static_assert((i < _d_e_g_r_e_e()), "child index out of range"); │ │ │ │ │ -116 return *_children[i]; │ │ │ │ │ -117 } │ │ │ │ │ -118 │ │ │ │ │ -120 │ │ │ │ │ -123 template │ │ │ │ │ -_1_2_4 std::shared_ptr _c_h_i_l_d_S_t_o_r_a_g_e (index_constant = {}) │ │ │ │ │ -125 { │ │ │ │ │ -126 static_assert((i < _d_e_g_r_e_e()), "child index out of range"); │ │ │ │ │ -127 return _children[i]; │ │ │ │ │ -128 } │ │ │ │ │ -129 │ │ │ │ │ -131 │ │ │ │ │ -134 template │ │ │ │ │ -_1_3_5 std::shared_ptr _c_h_i_l_d_S_t_o_r_a_g_e (index_constant = {}) const │ │ │ │ │ -136 { │ │ │ │ │ -137 static_assert((i < _d_e_g_r_e_e()), "child index out of range"); │ │ │ │ │ -138 return _children[i]; │ │ │ │ │ -139 } │ │ │ │ │ -140 │ │ │ │ │ -142 template │ │ │ │ │ -_1_4_3 void _s_e_t_C_h_i_l_d (T& t, index_constant = {}) │ │ │ │ │ -144 { │ │ │ │ │ -145 static_assert((i < _d_e_g_r_e_e()), "child index out of range"); │ │ │ │ │ -146 _children[i] = stackobject_to_shared_ptr(t); │ │ │ │ │ -147 } │ │ │ │ │ -148 │ │ │ │ │ -150 template │ │ │ │ │ -_1_5_1 void _s_e_t_C_h_i_l_d (T&& t, index_constant = {}) │ │ │ │ │ -152 { │ │ │ │ │ -153 static_assert((i < _d_e_g_r_e_e()), "child index out of range"); │ │ │ │ │ -154 _children[i] = convert_arg(std::move(t)); │ │ │ │ │ -155 } │ │ │ │ │ -156 │ │ │ │ │ -158 template │ │ │ │ │ -_1_5_9 void _s_e_t_C_h_i_l_d (std::shared_ptr st, index_constant = {}) │ │ │ │ │ -160 { │ │ │ │ │ -161 static_assert((i < _d_e_g_r_e_e()), "child index out of range"); │ │ │ │ │ -162 _children[i] = std::move(st); │ │ │ │ │ -163 } │ │ │ │ │ -164 │ │ │ │ │ -166 │ │ │ │ │ -167 │ │ │ │ │ -170 │ │ │ │ │ -172 │ │ │ │ │ -_1_7_5 T& _c_h_i_l_d (std::size_t i) │ │ │ │ │ -176 { │ │ │ │ │ -177 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ -178 return *_children[i]; │ │ │ │ │ -179 } │ │ │ │ │ -180 │ │ │ │ │ -182 │ │ │ │ │ -_1_8_5 const T& _c_h_i_l_d (std::size_t i) const │ │ │ │ │ -186 { │ │ │ │ │ -187 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ -188 return *_children[i]; │ │ │ │ │ -189 } │ │ │ │ │ -190 │ │ │ │ │ -192 │ │ │ │ │ -_1_9_5 std::shared_ptr _c_h_i_l_d_S_t_o_r_a_g_e (std::size_t i) │ │ │ │ │ -196 { │ │ │ │ │ -197 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ -198 return _children[i]; │ │ │ │ │ -199 } │ │ │ │ │ -200 │ │ │ │ │ -202 │ │ │ │ │ -_2_0_5 std::shared_ptr _c_h_i_l_d_S_t_o_r_a_g_e (std::size_t i) const │ │ │ │ │ -206 { │ │ │ │ │ -207 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ -208 return _children[i]; │ │ │ │ │ -209 } │ │ │ │ │ -210 │ │ │ │ │ -_2_1_2 void _s_e_t_C_h_i_l_d (std::size_t i, T& t) │ │ │ │ │ -213 { │ │ │ │ │ -214 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ -215 _children[i] = stackobject_to_shared_ptr(t); │ │ │ │ │ -216 } │ │ │ │ │ -217 │ │ │ │ │ -_2_1_9 void _s_e_t_C_h_i_l_d (std::size_t i, T&& t) │ │ │ │ │ -220 { │ │ │ │ │ -221 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ -222 _children[i] = convert_arg(std::move(t)); │ │ │ │ │ -223 } │ │ │ │ │ -224 │ │ │ │ │ -_2_2_6 void _s_e_t_C_h_i_l_d (std::size_t i, std::shared_ptr st) │ │ │ │ │ -227 { │ │ │ │ │ -228 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ -229 _children[i] = std::move(st); │ │ │ │ │ -230 } │ │ │ │ │ -231 │ │ │ │ │ -_2_3_2 const _N_o_d_e_S_t_o_r_a_g_e& _n_o_d_e_S_t_o_r_a_g_e () const │ │ │ │ │ -233 { │ │ │ │ │ -234 return _children; │ │ │ │ │ -235 } │ │ │ │ │ -236 │ │ │ │ │ -238 │ │ │ │ │ -241 │ │ │ │ │ -242 // The following two methods require a little bit of SFINAE trickery to │ │ │ │ │ -work correctly: │ │ │ │ │ -243 // We have to make sure that they don't shadow the methods for direct child │ │ │ │ │ -access because │ │ │ │ │ -244 // those get called by the generic child() machinery. If that machinery │ │ │ │ │ -picks up the methods │ │ │ │ │ -245 // defined below, we have an infinite recursion. │ │ │ │ │ -246 // So the methods make sure that either │ │ │ │ │ -247 // │ │ │ │ │ -248 // * there are more than one argument. In that case, we got multiple │ │ │ │ │ -indices and can forward │ │ │ │ │ -249 // to the general machine. │ │ │ │ │ -250 // │ │ │ │ │ -251 // * the first argument is not a valid flat index, i.e. either a std:: │ │ │ │ │ -size_t or an index_constant. │ │ │ │ │ -252 // The argument thus has to be some kind of TreePath instance that we can │ │ │ │ │ -also pass to the │ │ │ │ │ -253 // generic machine. │ │ │ │ │ -254 // │ │ │ │ │ -255 // The above SFINAE logic works, but there is still a problem with the │ │ │ │ │ -return type deduction. │ │ │ │ │ -256 // We have to do a lazy lookup of the return type after SFINAE has │ │ │ │ │ -succeeded, otherwise the return │ │ │ │ │ -257 // type deduction will trigger the infinite recursion. │ │ │ │ │ -258 │ │ │ │ │ -260 │ │ │ │ │ -264#ifdef DOXYGEN │ │ │ │ │ -265 template │ │ │ │ │ -_2_6_6 ImplementationDefined& _c_h_i_l_d (Indices... indices) │ │ │ │ │ -267#else │ │ │ │ │ -268 template 0) || _I_s_T_r_e_e_P_a_t_h_<_I_0_>_:_:_v_a_l_u_e, int > = 0> │ │ │ │ │ -270 decltype(auto) _c_h_i_l_d (I0 i0, I... i) │ │ │ │ │ -271#endif │ │ │ │ │ -272 { │ │ │ │ │ -273 static_assert(sizeof...(I) > 0 || impl::_non_empty_tree_path(I0{}), │ │ │ │ │ -274 "You cannot use the member function child() with an empty TreePath, use the │ │ │ │ │ -freestanding version child(node,treePath) instead." │ │ │ │ │ -275 ); │ │ │ │ │ -276 return _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_c_h_i_l_d(*this,i0,i...); │ │ │ │ │ -277 } │ │ │ │ │ -278 │ │ │ │ │ -280 │ │ │ │ │ -284#ifdef DOXYGEN │ │ │ │ │ -285 template │ │ │ │ │ -_2_8_6 const ImplementationDefined& _c_h_i_l_d (Indices... indices) │ │ │ │ │ -287#else │ │ │ │ │ -288 template 0) || _I_s_T_r_e_e_P_a_t_h_<_I_0_>_:_:_v_a_l_u_e, int > = 0> │ │ │ │ │ -290 decltype(auto) _c_h_i_l_d (I0 i0, I... i) const │ │ │ │ │ -291#endif │ │ │ │ │ -292 { │ │ │ │ │ -293 static_assert(sizeof...(I) > 0 || impl::_non_empty_tree_path(I0{}), │ │ │ │ │ -294 "You cannot use the member function child() with an empty TreePath, use the │ │ │ │ │ -freestanding version child(node,treePath) instead." │ │ │ │ │ -295 ); │ │ │ │ │ -296 return _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_c_h_i_l_d(*this,i0,i...); │ │ │ │ │ -297 } │ │ │ │ │ -298 │ │ │ │ │ -300 │ │ │ │ │ -303 │ │ │ │ │ -304 protected: │ │ │ │ │ -305 │ │ │ │ │ -307 │ │ │ │ │ -_3_1_5 _P_o_w_e_r_N_o_d_e () │ │ │ │ │ -316 {} │ │ │ │ │ -317 │ │ │ │ │ -_3_1_9 explicit _P_o_w_e_r_N_o_d_e (const _N_o_d_e_S_t_o_r_a_g_e& children) │ │ │ │ │ -320 : _children(children) │ │ │ │ │ -321 {} │ │ │ │ │ -322 │ │ │ │ │ -_3_2_4 explicit _P_o_w_e_r_N_o_d_e (T& t, bool distinct_objects = true) │ │ │ │ │ -325 { │ │ │ │ │ -326 if (distinct_objects) │ │ │ │ │ -327 { │ │ │ │ │ -328 for (typename NodeStorage::iterator it = _children.begin(); it != │ │ │ │ │ -_children.end(); ++it) │ │ │ │ │ -329 *it = std::make_shared(t); │ │ │ │ │ -330 } │ │ │ │ │ -331 else │ │ │ │ │ -332 { │ │ │ │ │ -333 std::shared_ptr sp = stackobject_to_shared_ptr(t); │ │ │ │ │ -334 std::fill(_children.begin(),_children.end(),sp); │ │ │ │ │ -335 } │ │ │ │ │ -336 } │ │ │ │ │ -337 │ │ │ │ │ -338#ifdef DOXYGEN │ │ │ │ │ -339 │ │ │ │ │ -_3_4_1 _P_o_w_e_r_N_o_d_e(T& t1, T& t2, ...) │ │ │ │ │ -342 {} │ │ │ │ │ -343 │ │ │ │ │ -344#else │ │ │ │ │ -345 │ │ │ │ │ -346 template>...>::value │ │ │ │ │ -349 ,int> = 0> │ │ │ │ │ -350 _P_o_w_e_r_N_o_d_e (Children&&... children) │ │ │ │ │ -351 { │ │ │ │ │ -352 static_assert(_d_e_g_r_e_e() == sizeof...(Children), "PowerNode constructor is │ │ │ │ │ -called with incorrect number of children"); │ │ │ │ │ -353 _children = _N_o_d_e_S_t_o_r_a_g_e{convert_arg(std::forward(children))...}; │ │ │ │ │ -354 } │ │ │ │ │ -355 │ │ │ │ │ -356 template...>::value │ │ │ │ │ -359 ,int> = 0> │ │ │ │ │ -360 _P_o_w_e_r_N_o_d_e (std::shared_ptr... children) │ │ │ │ │ -361 { │ │ │ │ │ -362 static_assert(_d_e_g_r_e_e() == sizeof...(Children), "PowerNode constructor is │ │ │ │ │ -called with incorrect number of children"); │ │ │ │ │ -363 _children = _N_o_d_e_S_t_o_r_a_g_e{children...}; │ │ │ │ │ -364 } │ │ │ │ │ -365 │ │ │ │ │ -366#endif // DOXYGEN │ │ │ │ │ -367 │ │ │ │ │ -369 │ │ │ │ │ -370 private: │ │ │ │ │ -371 _N_o_d_e_S_t_o_r_a_g_e _children; │ │ │ │ │ -372 }; │ │ │ │ │ -373 │ │ │ │ │ -375 │ │ │ │ │ -376 } // namespace TypeTree │ │ │ │ │ -377} //namespace Dune │ │ │ │ │ -378 │ │ │ │ │ -379#endif // DUNE_TYPETREE_POWERNODE_HH │ │ │ │ │ -_t_y_p_e_t_r_a_i_t_s_._h_h │ │ │ │ │ -_u_t_i_l_i_t_y_._h_h │ │ │ │ │ -_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h │ │ │ │ │ +110 } // namespace Detail │ │ │ │ │ +111 │ │ │ │ │ +113 │ │ │ │ │ +127 template │ │ │ │ │ +_1_2_8 void _a_p_p_l_y_T_o_T_r_e_e_P_a_i_r(Tree1&& tree1, Tree2&& tree2, Visitor&& visitor) │ │ │ │ │ +129 { │ │ │ │ │ +130 _D_e_t_a_i_l_:_:_a_p_p_l_y_T_o_T_r_e_e_P_a_i_r(tree1, tree2, _h_y_b_r_i_d_T_r_e_e_P_a_t_h(), visitor); │ │ │ │ │ +131 } │ │ │ │ │ +132 │ │ │ │ │ +134 │ │ │ │ │ +135 } // namespace TypeTree │ │ │ │ │ +136} //namespace Dune │ │ │ │ │ +137 │ │ │ │ │ +138#endif // DUNE_TYPETREE_PAIRTRAVERSAL_HH │ │ │ │ │ _n_o_d_e_t_a_g_s_._h_h │ │ │ │ │ -_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 │ │ │ │ │ +_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h │ │ │ │ │ +_t_r_a_v_e_r_s_a_l_._h_h │ │ │ │ │ +_t_r_e_e_p_a_t_h_._h_h │ │ │ │ │ +_v_i_s_i_t_o_r_._h_h │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_p_p_l_y_T_o_T_r_e_e_P_a_i_r │ │ │ │ │ +void applyToTreePair(Tree1 &&tree1, Tree2 &&tree2, Visitor &&visitor) │ │ │ │ │ +Apply visitor to a pair of TypeTrees. │ │ │ │ │ +DDeeffiinniittiioonn pairtraversal.hh:128 │ │ │ │ │ +_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 │ │ │ │ │ +_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_:_:_P_o_w_e_r_N_o_d_e_T_a_g │ │ │ │ │ -Tag designating a power node. │ │ │ │ │ -DDeeffiinniittiioonn nodetags.hh:21 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e │ │ │ │ │ -Collect k instances of type T within a dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:52 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ -void setChild(T &t, index_constant< i >={}) │ │ │ │ │ -Sets the i-th child to the passed-in value. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:143 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ -T & child(std::size_t i) │ │ │ │ │ -Returns the i-th child. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:175 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ -const T & child(index_constant< i >={}) const │ │ │ │ │ -Returns the i-th child (const version). │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:113 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ -void setChild(std::shared_ptr< T > st, index_constant< i >={}) │ │ │ │ │ -Sets the stored value representing the i-th child to the passed-in value. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:159 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ -std::shared_ptr< T > childStorage(index_constant< i >={}) │ │ │ │ │ -Returns the storage of the i-th child. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:124 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_P_o_w_e_r_N_o_d_e │ │ │ │ │ -PowerNode(T &t1, T &t2,...) │ │ │ │ │ -Initialize all children with the passed-in objects. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:341 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_n_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ -const NodeStorage & nodeStorage() const │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:232 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ -std::array< std::shared_ptr< T >, k > NodeStorage │ │ │ │ │ -The type used for storing the children. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:77 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ -std::shared_ptr< const T > childStorage(index_constant< i >={}) const │ │ │ │ │ -Returns the storage of the i-th child (const version). │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:135 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_P_o_w_e_r_N_o_d_e │ │ │ │ │ -PowerNode(T &t, bool distinct_objects=true) │ │ │ │ │ -Initialize all children with copies of a storage object constructed from the │ │ │ │ │ -parameter t. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:324 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_N_o_d_e_T_a_g │ │ │ │ │ -PowerNodeTag NodeTag │ │ │ │ │ -The type tag that describes a PowerNode. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:71 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ -const T & child(std::size_t i) const │ │ │ │ │ -Returns the i-th child (const version). │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:185 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_d_e_g_r_e_e │ │ │ │ │ -static constexpr auto degree() │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:65 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ -std::shared_ptr< const T > childStorage(std::size_t i) const │ │ │ │ │ -Returns the storage of the i-th child (const version). │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:205 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ -void setChild(std::size_t i, std::shared_ptr< T > st) │ │ │ │ │ -Sets the stored value representing the i-th child to the passed-in value. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:226 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_i_s_C_o_m_p_o_s_i_t_e │ │ │ │ │ -static const bool isComposite │ │ │ │ │ -Mark this class as a non composite in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:63 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_i_s_L_e_a_f │ │ │ │ │ -static const bool isLeaf │ │ │ │ │ -Mark this class as non leaf in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:57 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_i_s_P_o_w_e_r │ │ │ │ │ -static const bool isPower │ │ │ │ │ -Mark this class as a power in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:60 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_P_o_w_e_r_N_o_d_e │ │ │ │ │ -PowerNode(const NodeStorage &children) │ │ │ │ │ -Initialize the PowerNode with a copy of the passed-in storage type. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:319 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_C_h_i_l_d_T_y_p_e │ │ │ │ │ -T ChildType │ │ │ │ │ -The type of each child. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:74 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ -T & child(index_constant< i >={}) │ │ │ │ │ -Returns the i-th child. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:102 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ -ImplementationDefined & child(Indices... indices) │ │ │ │ │ -Returns the child given by the list of indices. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:266 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ -void setChild(std::size_t i, T &&t) │ │ │ │ │ -Store the passed value in i-th child. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:219 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ -void setChild(T &&t, index_constant< i >={}) │ │ │ │ │ -Store the passed value in i-th child. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:151 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_P_o_w_e_r_N_o_d_e │ │ │ │ │ -PowerNode() │ │ │ │ │ -Default constructor. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:315 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ -const ImplementationDefined & child(Indices... indices) │ │ │ │ │ -Returns the child given by the list of indices. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:286 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ -void setChild(std::size_t i, T &t) │ │ │ │ │ -Sets the i-th child to the passed-in value. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:212 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ -std::shared_ptr< T > childStorage(std::size_t i) │ │ │ │ │ -Returns the storage of the i-th child. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:195 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_C_h_i_l_d │ │ │ │ │ -Access to the type and storage type of the i-th child. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:83 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_C_h_i_l_d_:_:_t_y_p_e │ │ │ │ │ -T type │ │ │ │ │ -The type of the child. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:91 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_:_:_C_h_i_l_d_:_:_T_y_p_e │ │ │ │ │ -T Type │ │ │ │ │ -The type of the child. │ │ │ │ │ -DDeeffiinniittiioonn powernode.hh:88 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_I_s_T_r_e_e_P_a_t_h │ │ │ │ │ -Check if type represents a tree path. │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:184 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_a_p_p_l_y_T_o_T_r_e_e_P_a_i_r │ │ │ │ │ +void applyToTreePair(T1 &&tree1, T2 &&tree2, TreePath treePath, V &&visitor) │ │ │ │ │ +DDeeffiinniittiioonn pairtraversal.hh:40 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00041.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: treepath.hh File Reference │ │ │ │ +dune-typetree: exceptions.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -71,191 +71,40 @@ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ Classes | │ │ │ │ -Namespaces | │ │ │ │ -Typedefs | │ │ │ │ -Enumerations | │ │ │ │ -Functions
    │ │ │ │ -
    treepath.hh File Reference
    │ │ │ │ +Namespaces
    │ │ │ │ +
    exceptions.hh File Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ -
    #include <cstddef>
    │ │ │ │ -#include <cassert>
    │ │ │ │ -#include <iostream>
    │ │ │ │ -#include <type_traits>
    │ │ │ │ -#include <dune/common/documentation.hh>
    │ │ │ │ -#include <dune/common/version.hh>
    │ │ │ │ -#include <dune/common/typetraits.hh>
    │ │ │ │ -#include <dune/common/indices.hh>
    │ │ │ │ -#include <dune/common/hybridutilities.hh>
    │ │ │ │ -#include <dune/common/typelist.hh>
    │ │ │ │ -#include <dune/typetree/fixedcapacitystack.hh>
    │ │ │ │ -#include <dune/typetree/utility.hh>
    │ │ │ │ + │ │ │ │ +

    TypeTree-specific exceptions. │ │ │ │ +More...

    │ │ │ │ +
    #include <dune/common/exceptions.hh>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    class  Dune::TypeTree::HybridTreePath< T >
     A hybrid version of TreePath that supports both compile time and run time indices. More...
     
    struct  Dune::TypeTree::TreePathSize< HybridTreePath< index_constant< i >... > >
     
    struct  Dune::TypeTree::TreePathPushBack< HybridTreePath< index_constant< i >... >, k >
     
    struct  Dune::TypeTree::TreePathPushFront< HybridTreePath< index_constant< i >... >, k >
     
    struct  Dune::TypeTree::TreePathBack< HybridTreePath< index_constant< k > > >
     
    struct  Dune::TypeTree::TreePathBack< HybridTreePath< index_constant< j >, index_constant< k >, index_constant< l >... > >
     
    struct  Dune::TypeTree::TreePathFront< HybridTreePath< index_constant< k >, index_constant< i >... > >
     
    struct  Dune::TypeTree::TreePathPopBack< HybridTreePath< index_constant< k > >, i... >
     
    struct  Dune::TypeTree::TreePathPopBack< HybridTreePath< index_constant< j >, index_constant< k >, index_constant< l >... >, i... >
     
    struct  Dune::TypeTree::TreePathPopFront< HybridTreePath< index_constant< k >, index_constant< i >... > >
     
    struct  Dune::TypeTree::TreePathConcat< HybridTreePath< index_constant< i >... >, HybridTreePath< index_constant< k >... > >
    class  Dune::TypeTree::Exception
     Base class for all TypeTree exceptions. More...
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
     
    namespace  Dune::TypeTree::TreePathType
     
    namespace  Dune::TypeTree::Literals
     
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -

    │ │ │ │ -Typedefs

    template<std::size_t... i>
    using Dune::TypeTree::StaticTreePath = HybridTreePath< Dune::index_constant< i >... >
     
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -

    │ │ │ │ -Enumerations

    enum  Dune::TypeTree::TreePathType::Type { Dune::TypeTree::TreePathType::fullyStatic │ │ │ │ -, Dune::TypeTree::TreePathType::dynamic │ │ │ │ - }
     
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │

    │ │ │ │ -Functions

    template<std::size_t... i>
    void Dune::TypeTree::print_tree_path (std::ostream &os)
     
    template<std::size_t k, std::size_t... i>
    void Dune::TypeTree::print_tree_path (std::ostream &os)
     
    template<typename... T>
    constexpr auto Dune::TypeTree::makeTreePath (const T... t)
     helper function to construct a new HybridTreePath from the given indices.
     
    template<typename... T>
    constexpr auto Dune::TypeTree::hybridTreePath (const T &... t)
     Constructs a new HybridTreePath from the given indices.
     
    template<typename... T>
    constexpr auto Dune::TypeTree::treePath (const T &... t)
     Constructs a new HybridTreePath from the given indices.
     
    template<typename... T>
    constexpr std::size_t Dune::TypeTree::treePathSize (const HybridTreePath< T... > &)
     Returns the size (number of components) of the given HybridTreePath.
     
    template<std::size_t i, typename... T>
    constexpr auto Dune::TypeTree::treePathEntry (const HybridTreePath< T... > &tp, index_constant< i >={}) -> typename std::decay< decltype(std::get< i >(tp._data))>::type
     Returns a copy of the i-th element of the HybridTreePath.
     
    template<std::size_t i, typename... T>
    constexpr std::size_t Dune::TypeTree::treePathIndex (const HybridTreePath< T... > &tp, index_constant< i >={})
     Returns the index value of the i-th element of the HybridTreePath.
     
    template<typename... T>
    constexpr auto Dune::TypeTree::back (const HybridTreePath< T... > &tp) -> decltype(tp.back())
     Returns a copy of the last element of the HybridTreePath.
     
    template<typename... T>
    constexpr auto Dune::TypeTree::front (const HybridTreePath< T... > &tp) -> decltype(tp.front())
     Returns a copy of the first element of the HybridTreePath.
     
    template<typename... T>
    constexpr HybridTreePath< T..., std::size_t > Dune::TypeTree::push_back (const HybridTreePath< T... > &tp, std::size_t i)
     Appends a run time index to a HybridTreePath.
     
    template<std::size_t i, typename... T>
    constexpr HybridTreePath< T..., index_constant< i > > Dune::TypeTree::push_back (const HybridTreePath< T... > &tp, index_constant< i > i_={})
     Appends a compile time index to a HybridTreePath.
     
    template<typename... T>
    constexpr HybridTreePath< std::size_t, T... > Dune::TypeTree::push_front (const HybridTreePath< T... > &tp, std::size_t element)
     Prepends a run time index to a HybridTreePath.
     
    template<std::size_t i, typename... T>
    constexpr HybridTreePath< index_constant< i >, T... > Dune::TypeTree::push_front (const HybridTreePath< T... > &tp, index_constant< i > _i={})
     Prepends a compile time index to a HybridTreePath.
     
    template<typename I , typename... T, std::enable_if_t<(sizeof...(T) > 0), bool > = true>
    constexpr auto Dune::TypeTree::accumulate_back (const HybridTreePath< T... > &tp, I i)
     Hybrid utility that accumulates to the back of a multi-index.
     
    template<typename I , typename... T, std::enable_if_t<(sizeof...(T) > 0), bool > = true>
    constexpr auto Dune::TypeTree::accumulate_front (const HybridTreePath< T... > &tp, I i)
     Hybrid utility that accumulates to the front of a multi-index.
     
    template<class... Head, class... Other>
    constexpr auto Dune::TypeTree::join (const HybridTreePath< Head... > &head, const Other &... tail)
     Join two tree paths into one.
     
    template<class... T>
    constexpr auto Dune::TypeTree::reverse (const HybridTreePath< T... > &tp)
     Reverses the order of the elements in the path.
     
    template<class... T, std::enable_if_t<(sizeof...(T) > 0), bool > = true>
    constexpr auto Dune::TypeTree::pop_front (const HybridTreePath< T... > &tp)
     Removes first index on a HybridTreePath.
     
    template<class... T, std::enable_if_t<(sizeof...(T) > 0), bool > = true>
    constexpr auto Dune::TypeTree::pop_back (const HybridTreePath< T... > &tp)
     Removes last index on a HybridTreePath.
     
    template<class... S, class... T>
    constexpr bool Dune::TypeTree::operator== (const HybridTreePath< S... > &lhs, const HybridTreePath< T... > &rhs)
     Compare two HybridTreePaths for value equality.
     
    template<class S , S... lhs, class T , T... rhs>
    constexpr auto Dune::TypeTree::operator== (const HybridTreePath< std::integral_constant< S, lhs >... > &, const HybridTreePath< std::integral_constant< T, rhs >... > &)
     Overload for purely static HybridTreePaths.
     
    template<class... S, class... T>
    constexpr auto Dune::TypeTree::operator!= (const HybridTreePath< S... > &lhs, const HybridTreePath< T... > &rhs)
     Compare two HybridTreePaths for unequality.
     
    template<class S , S... lhs, class T , T... rhs>
    constexpr auto Dune::TypeTree::operator!= (const HybridTreePath< std::integral_constant< S, lhs >... > &, const HybridTreePath< std::integral_constant< T, rhs >... > &)
     Compare two static HybridTreePaths for unequality.
     
    template<char... digits>
    constexpr auto Dune::TypeTree::Literals::operator""_tp ()
     Literal to create treepath.
     
    template<typename... T>
    std::ostream & Dune::TypeTree::operator<< (std::ostream &os, const HybridTreePath< T... > &tp)
     Dumps a HybridTreePath to a stream.
     
    │ │ │ │ -
    │ │ │ │ +

    Detailed Description

    │ │ │ │ +

    TypeTree-specific exceptions.

    │ │ │ │ +
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,242 +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 | _T_y_p_e_d_e_f_s | _E_n_u_m_e_r_a_t_i_o_n_s | _F_u_n_c_t_i_o_n_s │ │ │ │ │ -treepath.hh File Reference │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_f_i_x_e_d_c_a_p_a_c_i_t_y_s_t_a_c_k_._h_h> │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_u_t_i_l_i_t_y_._h_h> │ │ │ │ │ +_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s │ │ │ │ │ +exceptions.hh File Reference │ │ │ │ │ +TypeTree-specific exceptions. _M_o_r_e_._._. │ │ │ │ │ +#include │ │ │ │ │ _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 │ │ │ │ │ - class   _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_<_ _T_ _> │ │ │ │ │ -  A hybrid version of TreePath that supports both compile time and run │ │ │ │ │ - time indices. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_S_i_z_e_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i_ _>_._._._ _> │ │ │ │ │ - _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_u_s_h_B_a_c_k_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i │ │ │ │ │ - _>_._._._ _>_,_ _k_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_u_s_h_F_r_o_n_t_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i │ │ │ │ │ - _>_._._._ _>_,_ _k_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_B_a_c_k_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _>_ _>_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_B_a_c_k_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _j_ _>_, │ │ │ │ │ - _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _>_,_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _l_ _>_._._._ _>_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_F_r_o_n_t_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _>_, │ │ │ │ │ - _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i_ _>_._._._ _>_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_o_p_B_a_c_k_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _> │ │ │ │ │ - _>_,_ _i_._._._ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_o_p_B_a_c_k_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _j_ _>_, │ │ │ │ │ - _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _>_,_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _l_ _>_._._._ _>_,_ _i_._._._ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_o_p_F_r_o_n_t_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _>_, │ │ │ │ │ - _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i_ _>_._._._ _>_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_C_o_n_c_a_t_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i_ _>_._._. │ │ │ │ │ - _>_,_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _>_._._._ _>_ _> │ │ │ │ │ +class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_c_e_p_t_i_o_n │ │ │ │ │ +  Base class for all _T_y_p_e_T_r_e_e exceptions. _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_:_:_T_r_e_e_P_a_t_h_T_y_p_e │ │ │ │ │ -  │ │ │ │ │ -namespace   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_i_t_e_r_a_l_s │ │ │ │ │ -  │ │ │ │ │ -TTyyppeeddeeffss │ │ │ │ │ -template │ │ │ │ │ -using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_T_r_e_e_P_a_t_h = _H_y_b_r_i_d_T_r_e_e_P_a_t_h< Dune::index_constant< i │ │ │ │ │ - >... > │ │ │ │ │ -  │ │ │ │ │ -EEnnuummeerraattiioonnss │ │ │ │ │ -enum   _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 { _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_T_y_p_e_:_: │ │ │ │ │ - _f_u_l_l_y_S_t_a_t_i_c , _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 } │ │ │ │ │ -  │ │ │ │ │ -FFuunnccttiioonnss │ │ │ │ │ -template │ │ │ │ │ - void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_r_i_n_t___t_r_e_e___p_a_t_h (std:: │ │ │ │ │ - ostream &os) │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_r_i_n_t___t_r_e_e___p_a_t_h (std:: │ │ │ │ │ - ostream &os) │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_a_k_e_T_r_e_e_P_a_t_h (const T... │ │ │ │ │ - t) │ │ │ │ │ -  helper function to construct a new │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h from the given indices. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - constexpr auto  _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 (const T │ │ │ │ │ - &... t) │ │ │ │ │ -  Constructs a new _H_y_b_r_i_d_T_r_e_e_P_a_t_h from the │ │ │ │ │ - given indices. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_t_r_e_e_P_a_t_h (const T &... │ │ │ │ │ - t) │ │ │ │ │ -  Constructs a new _H_y_b_r_i_d_T_r_e_e_P_a_t_h from the │ │ │ │ │ - given indices. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - constexpr std::size_t  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_t_r_e_e_P_a_t_h_S_i_z_e (const │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &) │ │ │ │ │ -  Returns the size (number of components) │ │ │ │ │ - of the given _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_t_r_e_e_P_a_t_h_E_n_t_r_y (const │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp, │ │ │ │ │ - index_constant< i >={}) -> typename │ │ │ │ │ - std::decay< decltype(std::get< i > │ │ │ │ │ - (tp._data))>::type │ │ │ │ │ -  Returns a copy of the i-th element of │ │ │ │ │ - the _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - constexpr std::size_t  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_t_r_e_e_P_a_t_h_I_n_d_e_x (const │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp, │ │ │ │ │ - index_constant< i >={}) │ │ │ │ │ -  Returns the index value of the i-th │ │ │ │ │ - element of the _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_b_a_c_k (const │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp) -> decltype │ │ │ │ │ - (tp.back()) │ │ │ │ │ -  Returns a copy of the last element of │ │ │ │ │ - the _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_r_o_n_t (const │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp) -> decltype │ │ │ │ │ - (tp.front()) │ │ │ │ │ -  Returns a copy of the first element of │ │ │ │ │ - the _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T..., std:: _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_u_s_h___b_a_c_k (const │ │ │ │ │ - size_t >  _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp, std::size_t │ │ │ │ │ - i) │ │ │ │ │ -  Appends a run time index to a │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T..., _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_u_s_h___b_a_c_k (const │ │ │ │ │ - index_constant< i > >  _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp, │ │ │ │ │ - index_constant< i > i_={}) │ │ │ │ │ -  Appends a compile time index to a │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ -constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h< std::size_t, _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_u_s_h___f_r_o_n_t (const │ │ │ │ │ - T... >  _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp, std::size_t │ │ │ │ │ - element) │ │ │ │ │ -  Prepends a run time index to a │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h< _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_u_s_h___f_r_o_n_t (const │ │ │ │ │ - index_constant< i >, T... >  _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp, │ │ │ │ │ - index_constant< i > _i={}) │ │ │ │ │ -  Prepends a compile time index to a │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ -  │ │ │ │ │ -template 0), bool │ │ │ │ │ -> = true> │ │ │ │ │ - constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_c_c_u_m_u_l_a_t_e___b_a_c_k (const │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp, I i) │ │ │ │ │ -  Hybrid utility that accumulates to the │ │ │ │ │ - back of a multi-index. │ │ │ │ │ -  │ │ │ │ │ -template 0), bool │ │ │ │ │ -> = true> │ │ │ │ │ - constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_c_c_u_m_u_l_a_t_e___f_r_o_n_t (const │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp, I i) │ │ │ │ │ -  Hybrid utility that accumulates to the │ │ │ │ │ - front of a multi-index. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_j_o_i_n (const │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h< Head... > &head, const │ │ │ │ │ - Other &... tail) │ │ │ │ │ -  Join two tree paths into one. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_r_e_v_e_r_s_e (const │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp) │ │ │ │ │ -  Reverses the order of the elements in │ │ │ │ │ - the path. │ │ │ │ │ -  │ │ │ │ │ -template 0), bool > = true> │ │ │ │ │ - constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_o_p___f_r_o_n_t (const │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp) │ │ │ │ │ -  Removes first index on a _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ -  │ │ │ │ │ -template 0), bool > = true> │ │ │ │ │ - constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_o_p___b_a_c_k (const │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp) │ │ │ │ │ -  Removes last index on a _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - constexpr bool  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_p_e_r_a_t_o_r_=_= (const │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h< S... > &lhs, const │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &rhs) │ │ │ │ │ -  Compare two _H_y_b_r_i_d_T_r_e_e_P_a_t_hs for value │ │ │ │ │ - equality. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_p_e_r_a_t_o_r_=_= (const │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h< std::integral_constant< │ │ │ │ │ - S, lhs >... > &, const _H_y_b_r_i_d_T_r_e_e_P_a_t_h< │ │ │ │ │ - std::integral_constant< T, rhs >... > &) │ │ │ │ │ -  Overload for purely static │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_hs. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_p_e_r_a_t_o_r_!_= (const │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h< S... > &lhs, const │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &rhs) │ │ │ │ │ -  Compare two _H_y_b_r_i_d_T_r_e_e_P_a_t_hs for │ │ │ │ │ - unequality. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_p_e_r_a_t_o_r_!_= (const │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h< std::integral_constant< │ │ │ │ │ - S, lhs >... > &, const _H_y_b_r_i_d_T_r_e_e_P_a_t_h< │ │ │ │ │ - std::integral_constant< T, rhs >... > &) │ │ │ │ │ -  Compare two static _H_y_b_r_i_d_T_r_e_e_P_a_t_hs for │ │ │ │ │ - unequality. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_i_t_e_r_a_l_s_:_:_o_p_e_r_a_t_o_r_"_"___t_p │ │ │ │ │ - () │ │ │ │ │ -  Literal to create treepath. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - std::ostream &  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_p_e_r_a_t_o_r_<_< (std::ostream │ │ │ │ │ - &os, const _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp) │ │ │ │ │ -  Dumps a _H_y_b_r_i_d_T_r_e_e_P_a_t_h to a stream. │ │ │ │ │ -  │ │ │ │ │ +********** DDeettaaiilleedd DDeessccrriippttiioonn ********** │ │ │ │ │ +TypeTree-specific exceptions. │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00041_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: treepath.hh Source File │ │ │ │ +dune-typetree: exceptions.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,734 +74,41 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ -
    treepath.hh
    │ │ │ │ +
    exceptions.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ -Go to the documentation of this file.
    1// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
    │ │ │ │ -
    2// vi: set et ts=8 sw=2 sts=2:
    │ │ │ │ +Go to the documentation of this file.
    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_TREEPATH_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_TREEPATH_HH
    │ │ │ │ -
    8
    │ │ │ │ -
    9#include <cstddef>
    │ │ │ │ -
    10#include <cassert>
    │ │ │ │ -
    11#include <iostream>
    │ │ │ │ -
    12#include <type_traits>
    │ │ │ │ -
    13
    │ │ │ │ -
    14#include <dune/common/documentation.hh>
    │ │ │ │ -
    15#include <dune/common/version.hh>
    │ │ │ │ -
    16#include <dune/common/typetraits.hh>
    │ │ │ │ -
    17#include <dune/common/indices.hh>
    │ │ │ │ -
    18#include <dune/common/hybridutilities.hh>
    │ │ │ │ -
    19#include <dune/common/typelist.hh>
    │ │ │ │ -
    20
    │ │ │ │ -
    21#include <dune/typetree/fixedcapacitystack.hh>
    │ │ │ │ -
    22#include <dune/typetree/utility.hh>
    │ │ │ │ -
    23
    │ │ │ │ -
    24namespace Dune {
    │ │ │ │ -
    25 namespace TypeTree {
    │ │ │ │ -
    26
    │ │ │ │ -
    27 // The Impl namespace collects some free standing functions helper functions
    │ │ │ │ -
    28 namespace Impl {
    │ │ │ │ -
    29 template<typename T>
    │ │ │ │ -
    30 struct check_size_t_impl
    │ │ │ │ -
    31 {
    │ │ │ │ -
    32 static constexpr auto check() {
    │ │ │ │ -
    33 return std::is_same_v<T, std::size_t>;
    │ │ │ │ -
    34 }
    │ │ │ │ -
    35 };
    │ │ │ │ -
    36
    │ │ │ │ -
    37 template<class T, T v>
    │ │ │ │ -
    38 struct check_size_t_impl<std::integral_constant<T,v>>
    │ │ │ │ -
    39 {
    │ │ │ │ -
    40 static constexpr auto check() {
    │ │ │ │ -
    41 return std::is_same_v<T, std::size_t>;
    │ │ │ │ -
    42 }
    │ │ │ │ -
    43 };
    │ │ │ │ -
    44
    │ │ │ │ -
    45 template<typename T>
    │ │ │ │ -
    46 constexpr auto check_size_t() {
    │ │ │ │ -
    47 return check_size_t_impl<T>::check();
    │ │ │ │ -
    48 }
    │ │ │ │ -
    49
    │ │ │ │ -
    50 template<typename T>
    │ │ │ │ -
    51 constexpr auto cast_size_t(const T & v) {
    │ │ │ │ -
    52 // check that T is an integral type that can be cast to std::size_t
    │ │ │ │ -
    53 static_assert(
    │ │ │ │ -
    54 std::is_convertible_v<T,std::size_t> &&
    │ │ │ │ -
    55 std::is_integral_v<T>,
    │ │ │ │ -
    56 "HybridTreePath indices must be convertible to std::size_t or std::integral_constant<std::size_t,v>");
    │ │ │ │ -
    57 // positivity can only be checked at run-time
    │ │ │ │ -
    58 assert(v >= 0 &&
    │ │ │ │ -
    59 "HybridTreePath indices must be convertible to std::size_t or std::integral_constant<std::size_t,v>");
    │ │ │ │ -
    60 return std::size_t(v);
    │ │ │ │ -
    61 }
    │ │ │ │ -
    62
    │ │ │ │ -
    63 template<class T, T v>
    │ │ │ │ -
    64 constexpr auto cast_size_t(std::integral_constant<T,v>) {
    │ │ │ │ -
    65 // check that T is an intergal type that can be cast to std::size_t
    │ │ │ │ -
    66 // and that v is positive
    │ │ │ │ -
    67 static_assert(
    │ │ │ │ -
    68 std::is_convertible_v<T,std::size_t> &&
    │ │ │ │ -
    69 std::is_integral_v<T> &&
    │ │ │ │ -
    70 v >= 0,
    │ │ │ │ -
    71 "HybridTreePath indices must be convertible to std::size_t or std::integral_constant<std::size_t,v>");
    │ │ │ │ -
    72 return std::integral_constant<std::size_t,v>();
    │ │ │ │ -
    73 }
    │ │ │ │ -
    74
    │ │ │ │ -
    75 // these are helper functions that help triggering a deprecation warning
    │ │ │ │ -
    76 template<typename T>
    │ │ │ │ -
    77 [[deprecated("HybridTreePath index storage should be std::size_t or std::integral_constant<std::size_t,v>!\n"
    │ │ │ │ -
    78 "Using anything else is deprecated and will not possible after the 2.10 release.\n"
    │ │ │ │ -
    79 "It is adviced not to specify the template parameters expicitly,\n"
    │ │ │ │ -
    80 "but to use the helper functions `hybridTreePath` or `treePath`."
    │ │ │ │ -
    81 "These take care of converting indices to the appropriate storage.")]]
    │ │ │ │ -
    82 constexpr bool check_storage_type(MetaType<T>) {
    │ │ │ │ -
    83 return false;
    │ │ │ │ -
    84 }
    │ │ │ │ -
    85
    │ │ │ │ -
    86 // specialization of valid index type
    │ │ │ │ -
    87 template<std::size_t v>
    │ │ │ │ -
    88 constexpr bool check_storage_type(MetaType<std::integral_constant<std::size_t,v>>) {
    │ │ │ │ -
    89 return true;
    │ │ │ │ -
    90 }
    │ │ │ │ -
    91
    │ │ │ │ -
    92 // specialization of valid index type
    │ │ │ │ -
    93 constexpr bool check_storage_type(MetaType<std::size_t>) {
    │ │ │ │ -
    94 return true;
    │ │ │ │ -
    95 }
    │ │ │ │ -
    96 }
    │ │ │ │ -
    97
    │ │ │ │ -
    98 template<typename... T>
    │ │ │ │ -
    99 class HybridTreePath;
    │ │ │ │ -
    100
    │ │ │ │ -
    104
    │ │ │ │ -
    │ │ │ │ -
    105 namespace TreePathType {
    │ │ │ │ -
    106 enum Type { fullyStatic, dynamic };
    │ │ │ │ -
    107 }
    │ │ │ │ -
    │ │ │ │ -
    108
    │ │ │ │ -
    109 template<typename>
    │ │ │ │ -
    110 struct TreePathSize;
    │ │ │ │ -
    111
    │ │ │ │ -
    112 template<typename,std::size_t>
    │ │ │ │ -
    113 struct TreePathPushBack;
    │ │ │ │ -
    114
    │ │ │ │ -
    115 template<typename,std::size_t>
    │ │ │ │ -
    116 struct TreePathPushFront;
    │ │ │ │ -
    117
    │ │ │ │ -
    118 template<typename>
    │ │ │ │ -
    119 struct TreePathBack;
    │ │ │ │ -
    120
    │ │ │ │ -
    121 template<typename>
    │ │ │ │ -
    122 struct TreePathFront;
    │ │ │ │ -
    123
    │ │ │ │ -
    124 template<typename, std::size_t...>
    │ │ │ │ -
    125 struct TreePathPopBack;
    │ │ │ │ -
    126
    │ │ │ │ -
    127 template<typename>
    │ │ │ │ -
    128 struct TreePathPopFront;
    │ │ │ │ -
    129
    │ │ │ │ -
    130 template<typename, typename>
    │ │ │ │ -
    131 struct TreePathConcat;
    │ │ │ │ -
    132
    │ │ │ │ -
    133 template<std::size_t... i>
    │ │ │ │ -
    │ │ │ │ -
    134 void print_tree_path(std::ostream& os)
    │ │ │ │ -
    135 {}
    │ │ │ │ -
    │ │ │ │ -
    136
    │ │ │ │ -
    137 template<std::size_t k, std::size_t... i>
    │ │ │ │ -
    │ │ │ │ -
    138 void print_tree_path(std::ostream& os)
    │ │ │ │ -
    139 {
    │ │ │ │ -
    140 os << k << " ";
    │ │ │ │ -
    141 print_tree_path<i...>(os);
    │ │ │ │ -
    142 }
    │ │ │ │ -
    │ │ │ │ -
    143
    │ │ │ │ -
    145
    │ │ │ │ -
    156 template<typename... T>
    │ │ │ │ -
    │ │ │ │ -
    157 class HybridTreePath
    │ │ │ │ -
    158 {
    │ │ │ │ -
    159
    │ │ │ │ -
    160 // enable check for dune-typetree 2.10 and above
    │ │ │ │ -
    161#if DUNE_VERSION_GTE(TYPETREE,2,10)
    │ │ │ │ -
    162 // make sure that all indices use std::size_t as the underlying number type
    │ │ │ │ -
    163 static_assert((... && Impl::check_size_t<T>()),
    │ │ │ │ -
    164 "HybridTreePath index storage must be std::size_t or std::integral_constant<std::size_t,v>");
    │ │ │ │ -
    165#endif
    │ │ │ │ -
    166
    │ │ │ │ -
    167 public:
    │ │ │ │ -
    168
    │ │ │ │ -
    170 using index_sequence = std::index_sequence_for<T...>;
    │ │ │ │ -
    171
    │ │ │ │ -
    │ │ │ │ -
    173 constexpr HybridTreePath()
    │ │ │ │ -
    174 {
    │ │ │ │ -
    175 [[maybe_unused]] constexpr bool check =
    │ │ │ │ -
    176 (... && Impl::check_storage_type(MetaType<T>()) );
    │ │ │ │ -
    177 }
    │ │ │ │ -
    │ │ │ │ -
    178
    │ │ │ │ -
    179 constexpr HybridTreePath(const HybridTreePath& tp) = default;
    │ │ │ │ -
    180 constexpr HybridTreePath(HybridTreePath&& tp) = default;
    │ │ │ │ -
    181
    │ │ │ │ -
    182 constexpr HybridTreePath& operator=(const HybridTreePath& tp) = default;
    │ │ │ │ -
    183 constexpr HybridTreePath& operator=(HybridTreePath&& tp) = default;
    │ │ │ │ -
    184
    │ │ │ │ -
    │ │ │ │ -
    186 explicit constexpr HybridTreePath(std::tuple<T...> t)
    │ │ │ │ -
    187 : _data(t)
    │ │ │ │ -
    188 {
    │ │ │ │ -
    189 [[maybe_unused]] constexpr bool check =
    │ │ │ │ -
    190 (... && Impl::check_storage_type(MetaType<T>()) );
    │ │ │ │ -
    191 }
    │ │ │ │ -
    │ │ │ │ -
    192
    │ │ │ │ -
    194 template<typename... U,
    │ │ │ │ -
    195 typename std::enable_if_t<(sizeof...(T) > 0 && sizeof...(U) == sizeof...(T)),bool> = true>
    │ │ │ │ -
    │ │ │ │ -
    196 explicit constexpr HybridTreePath(U... t)
    │ │ │ │ -
    197 : _data(t...) // we assume that all arguments are convertible to the types T...
    │ │ │ │ -
    198 {
    │ │ │ │ -
    199 [[maybe_unused]] constexpr bool check =
    │ │ │ │ -
    200 (... && Impl::check_storage_type(MetaType<T>()) );
    │ │ │ │ -
    201 }
    │ │ │ │ -
    │ │ │ │ -
    202
    │ │ │ │ -
    │ │ │ │ -
    204 [[nodiscard]] constexpr static index_sequence enumerate()
    │ │ │ │ -
    205 {
    │ │ │ │ -
    206 return {};
    │ │ │ │ -
    207 }
    │ │ │ │ -
    │ │ │ │ -
    208
    │ │ │ │ -
    │ │ │ │ -
    210 [[nodiscard]] constexpr static std::size_t size()
    │ │ │ │ -
    211 {
    │ │ │ │ -
    212 return sizeof...(T);
    │ │ │ │ -
    213 }
    │ │ │ │ -
    │ │ │ │ -
    214
    │ │ │ │ -
    │ │ │ │ -
    216 [[nodiscard]] constexpr static std::size_t max_size()
    │ │ │ │ -
    217 {
    │ │ │ │ -
    218 return size();
    │ │ │ │ -
    219 }
    │ │ │ │ -
    │ │ │ │ -
    220
    │ │ │ │ -
    222 template<std::size_t i,
    │ │ │ │ -
    223 std::enable_if_t<(sizeof...(T) > i),bool> = true>
    │ │ │ │ -
    │ │ │ │ -
    224 [[nodiscard]] constexpr auto operator[](Dune::index_constant<i>) const
    │ │ │ │ -
    225 {
    │ │ │ │ -
    226 return std::get<i>(_data);
    │ │ │ │ -
    227 }
    │ │ │ │ -
    │ │ │ │ -
    228
    │ │ │ │ -
    │ │ │ │ -
    230 [[nodiscard]] constexpr std::size_t operator[](std::size_t pos) const
    │ │ │ │ -
    231 {
    │ │ │ │ -
    232 std::size_t entry = 0;
    │ │ │ │ -
    233 Dune::Hybrid::forEach(enumerate(), [&] (auto i) {
    │ │ │ │ -
    234 if (i==pos)
    │ │ │ │ -
    235 entry = this->element(i);
    │ │ │ │ -
    236 });
    │ │ │ │ -
    237 return entry;
    │ │ │ │ -
    238 }
    │ │ │ │ -
    │ │ │ │ -
    239
    │ │ │ │ -
    241 template<std::size_t i,
    │ │ │ │ -
    242 std::enable_if_t<(sizeof...(T) > i),bool> = true>
    │ │ │ │ -
    │ │ │ │ -
    243 [[nodiscard]] constexpr auto element(Dune::index_constant<i> pos = {}) const
    │ │ │ │ -
    244 {
    │ │ │ │ -
    245 return std::get<i>(_data);
    │ │ │ │ -
    246 }
    │ │ │ │ -
    │ │ │ │ -
    247
    │ │ │ │ -
    │ │ │ │ -
    249 [[nodiscard]] constexpr std::size_t element(std::size_t pos) const
    │ │ │ │ -
    250 {
    │ │ │ │ -
    251 std::size_t entry = 0;
    │ │ │ │ -
    252 Dune::Hybrid::forEach(enumerate(), [&] (auto i) {
    │ │ │ │ -
    253 if (i==pos)
    │ │ │ │ -
    254 entry = this->element(i);
    │ │ │ │ -
    255 });
    │ │ │ │ -
    256 return entry;
    │ │ │ │ -
    257 }
    │ │ │ │ -
    │ │ │ │ -
    258
    │ │ │ │ -
    260 template<std::size_t n = sizeof...(T),
    │ │ │ │ -
    261 std::enable_if_t<(n > 0 && n == sizeof...(T)),bool> = true>
    │ │ │ │ -
    │ │ │ │ -
    262 [[nodiscard]] constexpr auto front() const
    │ │ │ │ -
    263 {
    │ │ │ │ -
    264 return std::get<0>(_data);
    │ │ │ │ -
    265 }
    │ │ │ │ -
    │ │ │ │ -
    266
    │ │ │ │ -
    268 template<std::size_t n = sizeof...(T),
    │ │ │ │ -
    269 std::enable_if_t<(n > 0 && n == sizeof...(T)),bool> = true>
    │ │ │ │ -
    │ │ │ │ -
    270 [[nodiscard]] constexpr auto back() const
    │ │ │ │ -
    271 {
    │ │ │ │ -
    272 return std::get<n-1>(_data);
    │ │ │ │ -
    273 }
    │ │ │ │ -
    │ │ │ │ -
    274
    │ │ │ │ -
    275#ifndef DOXYGEN
    │ │ │ │ -
    276
    │ │ │ │ -
    277 // I can't be bothered to make all the external accessors friends of HybridTreePath,
    │ │ │ │ -
    278 // so we'll only hide the data tuple from the user in Doxygen.
    │ │ │ │ -
    279
    │ │ │ │ -
    280 using Data = std::tuple<T...>;
    │ │ │ │ -
    281 Data _data;
    │ │ │ │ -
    282
    │ │ │ │ -
    283#endif // DOXYGEN
    │ │ │ │ -
    284
    │ │ │ │ -
    285 };
    │ │ │ │ -
    │ │ │ │ -
    286
    │ │ │ │ -
    288
    │ │ │ │ -
    294 template<typename... T>
    │ │ │ │ -
    │ │ │ │ -
    295 [[nodiscard]] constexpr auto makeTreePath(const T... t)
    │ │ │ │ -
    296 {
    │ │ │ │ -
    297 // check that all entries are based on std::size_t
    │ │ │ │ -
    298 static_assert((... && Impl::check_size_t<T>()),
    │ │ │ │ -
    299 "HybridTreePath indices must be of type std::size_t or std::integral_constant<std::size_t,v>");
    │ │ │ │ -
    300 return HybridTreePath<T...>(t...);
    │ │ │ │ -
    301 }
    │ │ │ │ -
    │ │ │ │ -
    302
    │ │ │ │ -
    304
    │ │ │ │ -
    311 template<typename... T>
    │ │ │ │ -
    │ │ │ │ -
    312 [[nodiscard]] constexpr auto hybridTreePath(const T&... t)
    │ │ │ │ -
    313 {
    │ │ │ │ -
    314 return makeTreePath(Impl::cast_size_t(t)...);
    │ │ │ │ -
    315 }
    │ │ │ │ -
    │ │ │ │ -
    316
    │ │ │ │ -
    318
    │ │ │ │ -
    325 template<typename... T>
    │ │ │ │ -
    │ │ │ │ -
    326 [[nodiscard]] constexpr auto treePath(const T&... t)
    │ │ │ │ -
    327 {
    │ │ │ │ -
    328 return makeTreePath(Impl::cast_size_t(t)...);
    │ │ │ │ -
    329 }
    │ │ │ │ -
    │ │ │ │ -
    330
    │ │ │ │ -
    331
    │ │ │ │ -
    333 template<typename... T>
    │ │ │ │ -
    │ │ │ │ -
    334 [[nodiscard]] constexpr std::size_t treePathSize(const HybridTreePath<T...>&)
    │ │ │ │ -
    335 {
    │ │ │ │ -
    336 return sizeof...(T);
    │ │ │ │ -
    337 }
    │ │ │ │ -
    │ │ │ │ -
    338
    │ │ │ │ -
    340
    │ │ │ │ -
    356 template<std::size_t i, typename... T>
    │ │ │ │ -
    │ │ │ │ -
    357 [[nodiscard]] constexpr auto treePathEntry(const HybridTreePath<T...>& tp, index_constant<i> = {})
    │ │ │ │ -
    358 -> typename std::decay<decltype(std::get<i>(tp._data))>::type
    │ │ │ │ -
    359 {
    │ │ │ │ -
    360 return std::get<i>(tp._data);
    │ │ │ │ -
    361 }
    │ │ │ │ -
    │ │ │ │ -
    362
    │ │ │ │ -
    364
    │ │ │ │ -
    379 template<std::size_t i,typename... T>
    │ │ │ │ -
    │ │ │ │ -
    380 [[nodiscard]] constexpr std::size_t treePathIndex(const HybridTreePath<T...>& tp, index_constant<i> = {})
    │ │ │ │ -
    381 {
    │ │ │ │ -
    382 return std::get<i>(tp._data);
    │ │ │ │ -
    383 }
    │ │ │ │ -
    │ │ │ │ -
    384
    │ │ │ │ -
    386
    │ │ │ │ -
    391 template<typename... T>
    │ │ │ │ -
    │ │ │ │ -
    392 [[nodiscard]] constexpr auto back(const HybridTreePath<T...>& tp)
    │ │ │ │ -
    393 -> decltype(tp.back())
    │ │ │ │ -
    394 {
    │ │ │ │ -
    395 return tp.back();
    │ │ │ │ -
    396 }
    │ │ │ │ -
    │ │ │ │ -
    397
    │ │ │ │ -
    399
    │ │ │ │ -
    404 template<typename... T>
    │ │ │ │ -
    │ │ │ │ -
    405 [[nodiscard]] constexpr auto front(const HybridTreePath<T...>& tp)
    │ │ │ │ -
    406 -> decltype(tp.front())
    │ │ │ │ -
    407 {
    │ │ │ │ -
    408 return tp.front();
    │ │ │ │ -
    409 }
    │ │ │ │ -
    │ │ │ │ -
    410
    │ │ │ │ -
    412
    │ │ │ │ -
    415 template<typename... T>
    │ │ │ │ -
    │ │ │ │ -
    416 [[nodiscard]] constexpr HybridTreePath<T...,std::size_t> push_back(const HybridTreePath<T...>& tp, std::size_t i)
    │ │ │ │ -
    417 {
    │ │ │ │ -
    418 return HybridTreePath<T...,std::size_t>(std::tuple_cat(tp._data,std::make_tuple(i)));
    │ │ │ │ -
    419 }
    │ │ │ │ -
    │ │ │ │ -
    420
    │ │ │ │ -
    422
    │ │ │ │ -
    436 template<std::size_t i, typename... T>
    │ │ │ │ -
    │ │ │ │ -
    437 [[nodiscard]] constexpr HybridTreePath<T...,index_constant<i>> push_back(const HybridTreePath<T...>& tp, index_constant<i> i_ = {})
    │ │ │ │ -
    438 {
    │ │ │ │ -
    439 return HybridTreePath<T...,index_constant<i> >(std::tuple_cat(tp._data,std::make_tuple(i_)));
    │ │ │ │ -
    440 }
    │ │ │ │ -
    │ │ │ │ -
    441
    │ │ │ │ -
    443
    │ │ │ │ -
    446 template<typename... T>
    │ │ │ │ -
    │ │ │ │ -
    447 [[nodiscard]] constexpr HybridTreePath<std::size_t,T...> push_front(const HybridTreePath<T...>& tp, std::size_t element)
    │ │ │ │ -
    448 {
    │ │ │ │ -
    449 return HybridTreePath<std::size_t,T...>(std::tuple_cat(std::make_tuple(element),tp._data));
    │ │ │ │ -
    450 }
    │ │ │ │ -
    │ │ │ │ -
    451
    │ │ │ │ -
    453
    │ │ │ │ -
    467 template<std::size_t i, typename... T>
    │ │ │ │ -
    │ │ │ │ -
    468 [[nodiscard]] constexpr HybridTreePath<index_constant<i>,T...> push_front(const HybridTreePath<T...>& tp, index_constant<i> _i = {})
    │ │ │ │ -
    469 {
    │ │ │ │ -
    470 return HybridTreePath<index_constant<i>,T...>(std::tuple_cat(std::make_tuple(_i),tp._data));
    │ │ │ │ -
    471 }
    │ │ │ │ -
    │ │ │ │ -
    472
    │ │ │ │ -
    474
    │ │ │ │ -
    485 template<typename I, typename... T, std::enable_if_t<(sizeof...(T) > 0),bool> = true>
    │ │ │ │ -
    │ │ │ │ -
    486 [[nodiscard]] constexpr auto accumulate_back(const HybridTreePath<T...>& tp, I i) {
    │ │ │ │ -
    487 using ::Dune::Hybrid::plus;
    │ │ │ │ -
    488 return push_back(pop_back(tp), plus(back(tp), i));
    │ │ │ │ -
    489 }
    │ │ │ │ -
    │ │ │ │ -
    490
    │ │ │ │ -
    491
    │ │ │ │ -
    493
    │ │ │ │ -
    504 template<typename I, typename... T, std::enable_if_t<(sizeof...(T) > 0),bool> = true>
    │ │ │ │ -
    │ │ │ │ -
    505 [[nodiscard]] constexpr auto accumulate_front(const HybridTreePath<T...>& tp, I i) {
    │ │ │ │ -
    506 using ::Dune::Hybrid::plus;
    │ │ │ │ -
    507 return push_front(pop_front(tp), plus(front(tp), i));
    │ │ │ │ -
    508 }
    │ │ │ │ -
    │ │ │ │ -
    509
    │ │ │ │ -
    511 template<class... Head, class... Other>
    │ │ │ │ -
    │ │ │ │ -
    512 [[nodiscard]] constexpr auto join(const HybridTreePath<Head...>& head, const Other&... tail) {
    │ │ │ │ -
    513 return TypeTree::HybridTreePath{std::tuple_cat(head._data, tail._data...)};
    │ │ │ │ -
    514 }
    │ │ │ │ -
    │ │ │ │ -
    515
    │ │ │ │ -
    517 template<class... T>
    │ │ │ │ -
    │ │ │ │ -
    518 [[nodiscard]] constexpr auto reverse(const HybridTreePath<T...>& tp) {
    │ │ │ │ -
    519 constexpr std::size_t size = sizeof...(T);
    │ │ │ │ -
    520 return unpackIntegerSequence([&](auto... i){
    │ │ │ │ -
    521 return treePath(tp[index_constant<size-i-1>{}] ...);
    │ │ │ │ -
    522 }, std::make_index_sequence<size>{});
    │ │ │ │ -
    523 }
    │ │ │ │ -
    │ │ │ │ -
    524
    │ │ │ │ -
    526
    │ │ │ │ -
    529 template <class... T, std::enable_if_t<(sizeof...(T) > 0),bool> = true>
    │ │ │ │ -
    │ │ │ │ -
    530 [[nodiscard]] constexpr auto pop_front(const HybridTreePath<T...>& tp)
    │ │ │ │ -
    531 {
    │ │ │ │ -
    532 return unpackIntegerSequence([&](auto... i){
    │ │ │ │ -
    533 return HybridTreePath{std::make_tuple(std::get<i+1>(tp._data)...)};
    │ │ │ │ -
    534 }, std::make_index_sequence<(sizeof...(T) - 1)>{});
    │ │ │ │ -
    535 }
    │ │ │ │ -
    │ │ │ │ -
    536
    │ │ │ │ -
    538
    │ │ │ │ -
    541 template <class... T, std::enable_if_t<(sizeof...(T) > 0),bool> = true>
    │ │ │ │ -
    │ │ │ │ -
    542 [[nodiscard]] constexpr auto pop_back(const HybridTreePath<T...>& tp)
    │ │ │ │ -
    543 {
    │ │ │ │ -
    544 return unpackIntegerSequence([&](auto... i){
    │ │ │ │ -
    545 return HybridTreePath{std::make_tuple(std::get<i>(tp._data)...)};
    │ │ │ │ -
    546 }, std::make_index_sequence<(sizeof...(T) - 1)>{});
    │ │ │ │ -
    547 }
    │ │ │ │ -
    │ │ │ │ -
    548
    │ │ │ │ -
    550
    │ │ │ │ -
    558 template <class... S, class... T>
    │ │ │ │ -
    │ │ │ │ -
    559 [[nodiscard]] constexpr bool operator==(
    │ │ │ │ -
    560 const HybridTreePath<S...>& lhs,
    │ │ │ │ -
    561 const HybridTreePath<T...>& rhs)
    │ │ │ │ -
    562 {
    │ │ │ │ -
    563 if constexpr (sizeof...(S) == sizeof...(T)) {
    │ │ │ │ -
    564 if constexpr ((Dune::IsInteroperable<S,T>::value &&...)) {
    │ │ │ │ -
    565 return unpackIntegerSequence([&](auto... i){
    │ │ │ │ -
    566 return ((std::get<i>(lhs._data) == std::get<i>(rhs._data)) &&...);
    │ │ │ │ -
    567 }, std::make_index_sequence<(sizeof...(S))>{});
    │ │ │ │ -
    568 } else {
    │ │ │ │ -
    569 return false;
    │ │ │ │ -
    570 }
    │ │ │ │ -
    571 } else {
    │ │ │ │ -
    572 return false;
    │ │ │ │ -
    573 }
    │ │ │ │ -
    574 }
    │ │ │ │ -
    │ │ │ │ -
    575
    │ │ │ │ -
    577
    │ │ │ │ -
    582 template <class S, S... lhs, class T, T... rhs>
    │ │ │ │ -
    │ │ │ │ -
    583 [[nodiscard]] constexpr auto operator==(
    │ │ │ │ -
    584 const HybridTreePath<std::integral_constant<S,lhs>...>&,
    │ │ │ │ -
    585 const HybridTreePath<std::integral_constant<T,rhs>...>&)
    │ │ │ │ -
    586 {
    │ │ │ │ -
    587 return std::bool_constant<hybridTreePath(lhs...) == hybridTreePath(rhs...)>{};
    │ │ │ │ -
    588 }
    │ │ │ │ -
    │ │ │ │ -
    589
    │ │ │ │ -
    590
    │ │ │ │ -
    592 template <class... S, class... T>
    │ │ │ │ -
    │ │ │ │ -
    593 [[nodiscard]] constexpr auto operator!=(
    │ │ │ │ -
    594 const HybridTreePath<S...>& lhs,
    │ │ │ │ -
    595 const HybridTreePath<T...>& rhs)
    │ │ │ │ -
    596 {
    │ │ │ │ -
    597 return !(lhs == rhs);
    │ │ │ │ -
    598 }
    │ │ │ │ -
    │ │ │ │ -
    599
    │ │ │ │ -
    601 template <class S, S... lhs, class T, T... rhs>
    │ │ │ │ -
    │ │ │ │ -
    602 [[nodiscard]] constexpr auto operator!=(
    │ │ │ │ -
    603 const HybridTreePath<std::integral_constant<S,lhs>...>&,
    │ │ │ │ -
    604 const HybridTreePath<std::integral_constant<T,rhs>...>&)
    │ │ │ │ -
    605 {
    │ │ │ │ -
    606 return std::bool_constant<hybridTreePath(lhs...) != hybridTreePath(rhs...)>{};
    │ │ │ │ -
    607 }
    │ │ │ │ -
    │ │ │ │ -
    608
    │ │ │ │ -
    609
    │ │ │ │ -
    │ │ │ │ -
    610 inline namespace Literals {
    │ │ │ │ -
    611
    │ │ │ │ -
    613
    │ │ │ │ -
    617 template <char... digits>
    │ │ │ │ -
    │ │ │ │ -
    618 constexpr auto operator"" _tp()
    │ │ │ │ -
    619 {
    │ │ │ │ -
    620 using namespace Dune::Indices::Literals;
    │ │ │ │ -
    621 return hybridTreePath(operator""_ic<digits...>());
    │ │ │ │ -
    622 }
    │ │ │ │ -
    │ │ │ │ -
    623
    │ │ │ │ -
    624 } // end namespace Literals
    │ │ │ │ -
    │ │ │ │ -
    625
    │ │ │ │ -
    626
    │ │ │ │ -
    627 template<std::size_t... i>
    │ │ │ │ -
    │ │ │ │ -
    628 struct TreePathSize<HybridTreePath<index_constant<i>...> >
    │ │ │ │ -
    629 : public index_constant<sizeof...(i)>
    │ │ │ │ -
    630 {};
    │ │ │ │ -
    │ │ │ │ -
    631
    │ │ │ │ -
    632
    │ │ │ │ -
    633 template<std::size_t k, std::size_t... i>
    │ │ │ │ -
    │ │ │ │ -
    634 struct TreePathPushBack<HybridTreePath<index_constant<i>...>,k>
    │ │ │ │ -
    635 {
    │ │ │ │ -
    636 typedef HybridTreePath<index_constant<i>...,index_constant<k>> type;
    │ │ │ │ -
    637 };
    │ │ │ │ -
    │ │ │ │ -
    638
    │ │ │ │ -
    639 template<std::size_t k, std::size_t... i>
    │ │ │ │ -
    │ │ │ │ -
    640 struct TreePathPushFront<HybridTreePath<index_constant<i>...>,k>
    │ │ │ │ -
    641 {
    │ │ │ │ -
    642 typedef HybridTreePath<index_constant<k>,index_constant<i>...> type;
    │ │ │ │ -
    643 };
    │ │ │ │ -
    │ │ │ │ -
    644
    │ │ │ │ -
    645 template<std::size_t k>
    │ │ │ │ -
    │ │ │ │ -
    646 struct TreePathBack<HybridTreePath<index_constant<k>>>
    │ │ │ │ -
    647 : public index_constant<k>
    │ │ │ │ -
    648 {};
    │ │ │ │ -
    │ │ │ │ -
    649
    │ │ │ │ -
    650 template<std::size_t j, std::size_t k, std::size_t... l>
    │ │ │ │ -
    │ │ │ │ -
    651 struct TreePathBack<HybridTreePath<index_constant<j>,index_constant<k>,index_constant<l>...>>
    │ │ │ │ -
    652 : public TreePathBack<HybridTreePath<index_constant<k>,index_constant<l>...>>
    │ │ │ │ -
    653 {};
    │ │ │ │ -
    │ │ │ │ -
    654
    │ │ │ │ -
    655 template<std::size_t k, std::size_t... i>
    │ │ │ │ -
    │ │ │ │ -
    656 struct TreePathFront<HybridTreePath<index_constant<k>,index_constant<i>...>>
    │ │ │ │ -
    657 : public index_constant<k>
    │ │ │ │ -
    658 {};
    │ │ │ │ -
    │ │ │ │ -
    659
    │ │ │ │ -
    660 template<std::size_t k, std::size_t... i>
    │ │ │ │ -
    │ │ │ │ -
    661 struct TreePathPopBack<HybridTreePath<index_constant<k>>,i...>
    │ │ │ │ -
    662 {
    │ │ │ │ -
    663 typedef HybridTreePath<index_constant<i>...> type;
    │ │ │ │ -
    664 };
    │ │ │ │ -
    │ │ │ │ -
    665
    │ │ │ │ -
    666 template<std::size_t j,
    │ │ │ │ -
    667 std::size_t k,
    │ │ │ │ -
    668 std::size_t... l,
    │ │ │ │ -
    669 std::size_t... i>
    │ │ │ │ -
    │ │ │ │ -
    670 struct TreePathPopBack<HybridTreePath<index_constant<j>,index_constant<k>,index_constant<l>...>,i...>
    │ │ │ │ -
    671 : public TreePathPopBack<HybridTreePath<index_constant<k>,index_constant<l>...>,i...,j>
    │ │ │ │ -
    672 {};
    │ │ │ │ -
    │ │ │ │ -
    673
    │ │ │ │ -
    674 template<std::size_t k, std::size_t... i>
    │ │ │ │ -
    │ │ │ │ -
    675 struct TreePathPopFront<HybridTreePath<index_constant<k>,index_constant<i>...> >
    │ │ │ │ -
    676 {
    │ │ │ │ -
    677 typedef HybridTreePath<index_constant<i>...> type;
    │ │ │ │ -
    678 };
    │ │ │ │ -
    │ │ │ │ -
    679
    │ │ │ │ -
    680 template<std::size_t... i, std::size_t... k>
    │ │ │ │ -
    │ │ │ │ -
    681 struct TreePathConcat<HybridTreePath<index_constant<i>...>,HybridTreePath<index_constant<k>...> >
    │ │ │ │ -
    682 {
    │ │ │ │ -
    683 typedef HybridTreePath<index_constant<i>...,index_constant<k>...> type;
    │ │ │ │ -
    684 };
    │ │ │ │ -
    │ │ │ │ -
    685
    │ │ │ │ -
    686#ifndef DOXYGEN
    │ │ │ │ -
    687
    │ │ │ │ -
    688 namespace impl {
    │ │ │ │ -
    689
    │ │ │ │ -
    690 // end of recursion
    │ │ │ │ -
    691 template<std::size_t i, typename... T>
    │ │ │ │ -
    692 typename std::enable_if<
    │ │ │ │ -
    693 (i == sizeof...(T))
    │ │ │ │ -
    694 >::type
    │ │ │ │ -
    695 print_hybrid_tree_path(std::ostream& os, const HybridTreePath<T...>& tp, index_constant<i> _i)
    │ │ │ │ -
    696 {}
    │ │ │ │ -
    697
    │ │ │ │ -
    698 // print current entry and recurse
    │ │ │ │ -
    699 template<std::size_t i, typename... T>
    │ │ │ │ -
    700 typename std::enable_if<
    │ │ │ │ -
    701 (i < sizeof...(T))
    │ │ │ │ -
    702 >::type
    │ │ │ │ -
    703 print_hybrid_tree_path(std::ostream& os, const HybridTreePath<T...>& tp, index_constant<i> _i)
    │ │ │ │ -
    704 {
    │ │ │ │ -
    705 os << treePathIndex(tp,_i) << " ";
    │ │ │ │ -
    706 print_hybrid_tree_path(os,tp,index_constant<i+1>{});
    │ │ │ │ -
    707 }
    │ │ │ │ -
    708
    │ │ │ │ -
    709 } // namespace impl
    │ │ │ │ -
    710
    │ │ │ │ -
    711#endif // DOXYGEN
    │ │ │ │ -
    712
    │ │ │ │ -
    714 template<typename... T>
    │ │ │ │ -
    │ │ │ │ -
    715 std::ostream& operator<<(std::ostream& os, const HybridTreePath<T...>& tp)
    │ │ │ │ -
    716 {
    │ │ │ │ -
    717 os << "HybridTreePath< ";
    │ │ │ │ -
    718 impl::print_hybrid_tree_path(os, tp, index_constant<0>{});
    │ │ │ │ -
    719 os << ">";
    │ │ │ │ -
    720 return os;
    │ │ │ │ -
    721 }
    │ │ │ │ -
    │ │ │ │ -
    722
    │ │ │ │ -
    723 template<std::size_t... i>
    │ │ │ │ -
    724 using StaticTreePath = HybridTreePath<Dune::index_constant<i>...>;
    │ │ │ │ -
    725
    │ │ │ │ -
    727
    │ │ │ │ -
    728 } // namespace TypeTree
    │ │ │ │ -
    729} //namespace Dune
    │ │ │ │ -
    730
    │ │ │ │ -
    731#endif // DUNE_TYPETREE_TREEPATH_HH
    │ │ │ │ - │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::push_back
    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
    │ │ │ │ -
    Dune::TypeTree::operator<<
    std::ostream & operator<<(std::ostream &os, const HybridTreePath< T... > &tp)
    Dumps a HybridTreePath to a stream.
    Definition treepath.hh:715
    │ │ │ │ -
    Dune::TypeTree::treePathSize
    constexpr std::size_t treePathSize(const HybridTreePath< T... > &)
    Returns the size (number of components) of the given HybridTreePath.
    Definition treepath.hh:334
    │ │ │ │ -
    Dune::TypeTree::back
    constexpr auto back(const HybridTreePath< T... > &tp) -> decltype(tp.back())
    Returns a copy of the last element of the HybridTreePath.
    Definition treepath.hh:392
    │ │ │ │ -
    Dune::TypeTree::push_front
    constexpr HybridTreePath< std::size_t, T... > push_front(const HybridTreePath< T... > &tp, std::size_t element)
    Prepends a run time index to a HybridTreePath.
    Definition treepath.hh:447
    │ │ │ │ -
    Dune::TypeTree::accumulate_front
    constexpr auto accumulate_front(const HybridTreePath< T... > &tp, I i)
    Hybrid utility that accumulates to the front of a multi-index.
    Definition treepath.hh:505
    │ │ │ │ -
    Dune::TypeTree::pop_front
    constexpr auto pop_front(const HybridTreePath< T... > &tp)
    Removes first index on a HybridTreePath.
    Definition treepath.hh:530
    │ │ │ │ -
    Dune::TypeTree::reverse
    constexpr auto reverse(const HybridTreePath< T... > &tp)
    Reverses the order of the elements in the path.
    Definition treepath.hh:518
    │ │ │ │ -
    Dune::TypeTree::accumulate_back
    constexpr auto accumulate_back(const HybridTreePath< T... > &tp, I i)
    Hybrid utility that accumulates to the back of a multi-index.
    Definition treepath.hh:486
    │ │ │ │ -
    Dune::TypeTree::join
    constexpr auto join(const HybridTreePath< Head... > &head, const Other &... tail)
    Join two tree paths into one.
    Definition treepath.hh:512
    │ │ │ │ -
    Dune::TypeTree::treePathEntry
    constexpr auto treePathEntry(const HybridTreePath< T... > &tp, index_constant< i >={}) -> typename std::decay< decltype(std::get< i >(tp._data))>::type
    Returns a copy of the i-th element of the HybridTreePath.
    Definition treepath.hh:357
    │ │ │ │ -
    Dune::TypeTree::pop_back
    constexpr auto pop_back(const HybridTreePath< T... > &tp)
    Removes last index on a HybridTreePath.
    Definition treepath.hh:542
    │ │ │ │ -
    Dune::TypeTree::operator!=
    constexpr auto operator!=(const HybridTreePath< S... > &lhs, const HybridTreePath< T... > &rhs)
    Compare two HybridTreePaths for unequality.
    Definition treepath.hh:593
    │ │ │ │ -
    Dune::TypeTree::hybridTreePath
    constexpr auto hybridTreePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:312
    │ │ │ │ -
    Dune::TypeTree::treePathIndex
    constexpr std::size_t treePathIndex(const HybridTreePath< T... > &tp, index_constant< i >={})
    Returns the index value of the i-th element of the HybridTreePath.
    Definition treepath.hh:380
    │ │ │ │ -
    Dune::TypeTree::makeTreePath
    constexpr auto makeTreePath(const T... t)
    helper function to construct a new HybridTreePath from the given indices.
    Definition treepath.hh:295
    │ │ │ │ -
    Dune::TypeTree::operator==
    constexpr bool operator==(const HybridTreePath< S... > &lhs, const HybridTreePath< T... > &rhs)
    Compare two HybridTreePaths for value equality.
    Definition treepath.hh:559
    │ │ │ │ -
    Dune::TypeTree::print_tree_path
    void print_tree_path(std::ostream &os)
    Definition treepath.hh:134
    │ │ │ │ -
    Dune::TypeTree::treePath
    constexpr auto treePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:326
    │ │ │ │ -
    Dune::TypeTree::front
    constexpr auto front(const HybridTreePath< T... > &tp) -> decltype(tp.front())
    Returns a copy of the first element of the HybridTreePath.
    Definition treepath.hh:405
    │ │ │ │ +
    5#ifndef DUNE_TYPETREE_EXCEPTIONS_HH
    │ │ │ │ +
    6#define DUNE_TYPETREE_EXCEPTIONS_HH
    │ │ │ │ +
    7
    │ │ │ │ +
    8#include <dune/common/exceptions.hh>
    │ │ │ │ +
    9
    │ │ │ │ +
    15namespace Dune {
    │ │ │ │ +
    16 namespace TypeTree {
    │ │ │ │ +
    17
    │ │ │ │ +
    │ │ │ │ +
    19 class Exception
    │ │ │ │ +
    20 : public Dune::Exception
    │ │ │ │ +
    21 {};
    │ │ │ │ +
    │ │ │ │ +
    22
    │ │ │ │ +
    23 } // namespace TypeTree
    │ │ │ │ +
    24} // namespace Dune
    │ │ │ │ +
    25
    │ │ │ │ +
    26#endif // DUNE_TYPETREE_EXCEPTIONS_HH
    │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::TreePathType::Type
    Type
    Definition treepath.hh:106
    │ │ │ │ -
    Dune::TypeTree::TreePathType::fullyStatic
    @ fullyStatic
    Definition treepath.hh:106
    │ │ │ │ -
    Dune::TypeTree::TreePathType::dynamic
    @ dynamic
    Definition treepath.hh:106
    │ │ │ │ -
    Dune::TypeTree::plus
    Statically combine two values of type result_type using +.
    Definition accumulate_static.hh:49
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath
    A hybrid version of TreePath that supports both compile time and run time indices.
    Definition treepath.hh:158
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath::HybridTreePath
    constexpr HybridTreePath(HybridTreePath &&tp)=default
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath::back
    constexpr auto back() const
    Get the last index value. Only available in non-empty paths.
    Definition treepath.hh:270
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath::operator=
    constexpr HybridTreePath & operator=(const HybridTreePath &tp)=default
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath::element
    constexpr std::size_t element(std::size_t pos) const
    Get the index value at position pos.
    Definition treepath.hh:249
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath::HybridTreePath
    constexpr HybridTreePath(std::tuple< T... > t)
    Constructor from a std::tuple
    Definition treepath.hh:186
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath::operator=
    constexpr HybridTreePath & operator=(HybridTreePath &&tp)=default
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath::HybridTreePath
    constexpr HybridTreePath(U... t)
    Constructor from arguments.
    Definition treepath.hh:196
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath::HybridTreePath
    constexpr HybridTreePath()
    Default constructor.
    Definition treepath.hh:173
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath::element
    constexpr auto element(Dune::index_constant< i > pos={}) const
    Get the last index value.
    Definition treepath.hh:243
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath::size
    static constexpr std::size_t size()
    Get the size (length) of this path.
    Definition treepath.hh:210
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath::operator[]
    constexpr auto operator[](Dune::index_constant< i >) const
    Get the index value at position pos.
    Definition treepath.hh:224
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath::front
    constexpr auto front() const
    Get the first index value. Only available in non-empty paths.
    Definition treepath.hh:262
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath::enumerate
    static constexpr index_sequence enumerate()
    Returns an index_sequence for enumerating the components of this HybridTreePath.
    Definition treepath.hh:204
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath::HybridTreePath
    constexpr HybridTreePath(const HybridTreePath &tp)=default
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath::operator[]
    constexpr std::size_t operator[](std::size_t pos) const
    Get the index value at position pos.
    Definition treepath.hh:230
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath::max_size
    static constexpr std::size_t max_size()
    Get the size (length) of this path.
    Definition treepath.hh:216
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath::index_sequence
    std::index_sequence_for< T... > index_sequence
    An index_sequence for the entries in this HybridTreePath.
    Definition treepath.hh:170
    │ │ │ │ -
    Dune::TypeTree::TreePathSize
    Definition treepath.hh:110
    │ │ │ │ -
    Dune::TypeTree::TreePathPushBack
    Definition treepath.hh:113
    │ │ │ │ -
    Dune::TypeTree::TreePathPushFront
    Definition treepath.hh:116
    │ │ │ │ -
    Dune::TypeTree::TreePathBack
    Definition treepath.hh:119
    │ │ │ │ -
    Dune::TypeTree::TreePathFront
    Definition treepath.hh:122
    │ │ │ │ -
    Dune::TypeTree::TreePathPopBack
    Definition treepath.hh:125
    │ │ │ │ -
    Dune::TypeTree::TreePathPopFront
    Definition treepath.hh:128
    │ │ │ │ -
    Dune::TypeTree::TreePathConcat
    Definition treepath.hh:131
    │ │ │ │ -
    Dune::TypeTree::TreePathPushBack< HybridTreePath< index_constant< i >... >, k >::type
    HybridTreePath< index_constant< i >..., index_constant< k > > type
    Definition treepath.hh:636
    │ │ │ │ -
    Dune::TypeTree::TreePathPushFront< HybridTreePath< index_constant< i >... >, k >::type
    HybridTreePath< index_constant< k >, index_constant< i >... > type
    Definition treepath.hh:642
    │ │ │ │ -
    Dune::TypeTree::TreePathPopBack< HybridTreePath< index_constant< k > >, i... >::type
    HybridTreePath< index_constant< i >... > type
    Definition treepath.hh:663
    │ │ │ │ -
    Dune::TypeTree::TreePathPopFront< HybridTreePath< index_constant< k >, index_constant< i >... > >::type
    HybridTreePath< index_constant< i >... > type
    Definition treepath.hh:677
    │ │ │ │ -
    Dune::TypeTree::TreePathConcat< HybridTreePath< index_constant< i >... >, HybridTreePath< index_constant< k >... > >::type
    HybridTreePath< index_constant< i >..., index_constant< k >... > type
    Definition treepath.hh:683
    │ │ │ │ +
    Dune::TypeTree::Exception
    Base class for all TypeTree exceptions.
    Definition exceptions.hh:21
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,812 +1,37 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -treepath.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: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- │ │ │ │ │ -2// vi: set et ts=8 sw=2 sts=2: │ │ │ │ │ +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_TREEPATH_HH │ │ │ │ │ -7#define DUNE_TYPETREE_TREEPATH_HH │ │ │ │ │ -8 │ │ │ │ │ -9#include │ │ │ │ │ -10#include │ │ │ │ │ -11#include │ │ │ │ │ -12#include │ │ │ │ │ -13 │ │ │ │ │ -14#include │ │ │ │ │ -15#include │ │ │ │ │ -16#include │ │ │ │ │ -17#include │ │ │ │ │ -18#include │ │ │ │ │ -19#include │ │ │ │ │ -20 │ │ │ │ │ -21#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_f_i_x_e_d_c_a_p_a_c_i_t_y_s_t_a_c_k_._h_h> │ │ │ │ │ -22#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_u_t_i_l_i_t_y_._h_h> │ │ │ │ │ -23 │ │ │ │ │ -24namespace _D_u_n_e { │ │ │ │ │ -25 namespace TypeTree { │ │ │ │ │ -26 │ │ │ │ │ -27 // The Impl namespace collects some free standing functions helper functions │ │ │ │ │ -28 namespace Impl { │ │ │ │ │ -29 template │ │ │ │ │ -30 struct check_size_t_impl │ │ │ │ │ -31 { │ │ │ │ │ -32 static constexpr auto check() { │ │ │ │ │ -33 return std::is_same_v; │ │ │ │ │ -34 } │ │ │ │ │ -35 }; │ │ │ │ │ -36 │ │ │ │ │ -37 template │ │ │ │ │ -38 struct check_size_t_impl> │ │ │ │ │ -39 { │ │ │ │ │ -40 static constexpr auto check() { │ │ │ │ │ -41 return std::is_same_v; │ │ │ │ │ -42 } │ │ │ │ │ -43 }; │ │ │ │ │ -44 │ │ │ │ │ -45 template │ │ │ │ │ -46 constexpr auto check_size_t() { │ │ │ │ │ -47 return check_size_t_impl::check(); │ │ │ │ │ -48 } │ │ │ │ │ -49 │ │ │ │ │ -50 template │ │ │ │ │ -51 constexpr auto cast_size_t(const T & v) { │ │ │ │ │ -52 // check that T is an integral type that can be cast to std::size_t │ │ │ │ │ -53 static_assert( │ │ │ │ │ -54 std::is_convertible_v && │ │ │ │ │ -55 std::is_integral_v, │ │ │ │ │ -56 "HybridTreePath indices must be convertible to std::size_t or std:: │ │ │ │ │ -integral_constant"); │ │ │ │ │ -57 // positivity can only be checked at run-time │ │ │ │ │ -58 assert(v >= 0 && │ │ │ │ │ -59 "HybridTreePath indices must be convertible to std::size_t or std:: │ │ │ │ │ -integral_constant"); │ │ │ │ │ -60 return std::size_t(v); │ │ │ │ │ -61 } │ │ │ │ │ -62 │ │ │ │ │ -63 template │ │ │ │ │ -64 constexpr auto cast_size_t(std::integral_constant) { │ │ │ │ │ -65 // check that T is an intergal type that can be cast to std::size_t │ │ │ │ │ -66 // and that v is positive │ │ │ │ │ -67 static_assert( │ │ │ │ │ -68 std::is_convertible_v && │ │ │ │ │ -69 std::is_integral_v && │ │ │ │ │ -70 v >= 0, │ │ │ │ │ -71 "HybridTreePath indices must be convertible to std::size_t or std:: │ │ │ │ │ -integral_constant"); │ │ │ │ │ -72 return std::integral_constant(); │ │ │ │ │ -73 } │ │ │ │ │ -74 │ │ │ │ │ -75 // these are helper functions that help triggering a deprecation warning │ │ │ │ │ -76 template │ │ │ │ │ -77 [[deprecated("HybridTreePath index storage should be std::size_t or std:: │ │ │ │ │ -integral_constant!\n" │ │ │ │ │ -78 "Using anything else is deprecated and will not possible after the 2.10 │ │ │ │ │ -release.\n" │ │ │ │ │ -79 "It is adviced not to specify the template parameters expicitly,\n" │ │ │ │ │ -80 "but to use the helper functions `hybridTreePath` or `treePath`." │ │ │ │ │ -81 "These take care of converting indices to the appropriate storage.")]] │ │ │ │ │ -82 constexpr bool check_storage_type(MetaType) { │ │ │ │ │ -83 return false; │ │ │ │ │ -84 } │ │ │ │ │ -85 │ │ │ │ │ -86 // specialization of valid index type │ │ │ │ │ -87 template │ │ │ │ │ -88 constexpr bool check_storage_type(MetaType>) { │ │ │ │ │ -89 return true; │ │ │ │ │ -90 } │ │ │ │ │ -91 │ │ │ │ │ -92 // specialization of valid index type │ │ │ │ │ -93 constexpr bool check_storage_type(MetaType) { │ │ │ │ │ -94 return true; │ │ │ │ │ -95 } │ │ │ │ │ -96 } │ │ │ │ │ -97 │ │ │ │ │ -98 template │ │ │ │ │ -99 class HybridTreePath; │ │ │ │ │ -100 │ │ │ │ │ -104 │ │ │ │ │ -_1_0_5 namespace TreePathType { │ │ │ │ │ -_1_0_6 enum _T_y_p_e { _f_u_l_l_y_S_t_a_t_i_c, _d_y_n_a_m_i_c }; │ │ │ │ │ -107 } │ │ │ │ │ -108 │ │ │ │ │ -109 template │ │ │ │ │ -_1_1_0 struct _T_r_e_e_P_a_t_h_S_i_z_e; │ │ │ │ │ -111 │ │ │ │ │ -112 template │ │ │ │ │ -_1_1_3 struct _T_r_e_e_P_a_t_h_P_u_s_h_B_a_c_k; │ │ │ │ │ -114 │ │ │ │ │ -115 template │ │ │ │ │ -_1_1_6 struct _T_r_e_e_P_a_t_h_P_u_s_h_F_r_o_n_t; │ │ │ │ │ -117 │ │ │ │ │ -118 template │ │ │ │ │ -_1_1_9 struct _T_r_e_e_P_a_t_h_B_a_c_k; │ │ │ │ │ -120 │ │ │ │ │ -121 template │ │ │ │ │ -_1_2_2 struct _T_r_e_e_P_a_t_h_F_r_o_n_t; │ │ │ │ │ -123 │ │ │ │ │ -124 template │ │ │ │ │ -_1_2_5 struct _T_r_e_e_P_a_t_h_P_o_p_B_a_c_k; │ │ │ │ │ -126 │ │ │ │ │ -127 template │ │ │ │ │ -_1_2_8 struct _T_r_e_e_P_a_t_h_P_o_p_F_r_o_n_t; │ │ │ │ │ -129 │ │ │ │ │ -130 template │ │ │ │ │ -_1_3_1 struct _T_r_e_e_P_a_t_h_C_o_n_c_a_t; │ │ │ │ │ -132 │ │ │ │ │ -133 template │ │ │ │ │ -_1_3_4 void _p_r_i_n_t___t_r_e_e___p_a_t_h(std::ostream& os) │ │ │ │ │ -135 {} │ │ │ │ │ -136 │ │ │ │ │ -137 template │ │ │ │ │ -_1_3_8 void _p_r_i_n_t___t_r_e_e___p_a_t_h(std::ostream& os) │ │ │ │ │ -139 { │ │ │ │ │ -140 os << k << " "; │ │ │ │ │ -141 _p_r_i_n_t___t_r_e_e___p_a_t_h(os); │ │ │ │ │ -142 } │ │ │ │ │ -143 │ │ │ │ │ -145 │ │ │ │ │ -156 template │ │ │ │ │ -_1_5_7 class _H_y_b_r_i_d_T_r_e_e_P_a_t_h │ │ │ │ │ -158 { │ │ │ │ │ -159 │ │ │ │ │ -160 // enable check for dune-typetree 2.10 and above │ │ │ │ │ -161#if DUNE_VERSION_GTE(TYPETREE,2,10) │ │ │ │ │ -162 // make sure that all indices use std::size_t as the underlying number type │ │ │ │ │ -163 static_assert((... && Impl::check_size_t()), │ │ │ │ │ -164 "HybridTreePath index storage must be std::size_t or std:: │ │ │ │ │ -integral_constant"); │ │ │ │ │ -165#endif │ │ │ │ │ -166 │ │ │ │ │ -167 public: │ │ │ │ │ -168 │ │ │ │ │ -_1_7_0 using _i_n_d_e_x___s_e_q_u_e_n_c_e = std::index_sequence_for; │ │ │ │ │ -171 │ │ │ │ │ -_1_7_3 constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h() │ │ │ │ │ -174 { │ │ │ │ │ -175 [[maybe_unused]] constexpr bool check = │ │ │ │ │ -176 (... && Impl::check_storage_type(MetaType()) ); │ │ │ │ │ -177 } │ │ │ │ │ -178 │ │ │ │ │ -_1_7_9 constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h& tp) = default; │ │ │ │ │ -_1_8_0 constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h(_H_y_b_r_i_d_T_r_e_e_P_a_t_h&& tp) = default; │ │ │ │ │ -181 │ │ │ │ │ -_1_8_2 constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h& _o_p_e_r_a_t_o_r_=(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h& tp) = default; │ │ │ │ │ -_1_8_3 constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h& _o_p_e_r_a_t_o_r_=(_H_y_b_r_i_d_T_r_e_e_P_a_t_h&& tp) = default; │ │ │ │ │ -184 │ │ │ │ │ -_1_8_6 explicit constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h(std::tuple t) │ │ │ │ │ -187 : _data(t) │ │ │ │ │ -188 { │ │ │ │ │ -189 [[maybe_unused]] constexpr bool check = │ │ │ │ │ -190 (... && Impl::check_storage_type(MetaType()) ); │ │ │ │ │ -191 } │ │ │ │ │ -192 │ │ │ │ │ -194 template 0 && sizeof...(U) == sizeof... │ │ │ │ │ -(T)),bool> = true> │ │ │ │ │ -_1_9_6 explicit constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h(U... t) │ │ │ │ │ -197 : _data(t...) // we assume that all arguments are convertible to the types │ │ │ │ │ -T... │ │ │ │ │ -198 { │ │ │ │ │ -199 [[maybe_unused]] constexpr bool check = │ │ │ │ │ -200 (... && Impl::check_storage_type(MetaType()) ); │ │ │ │ │ -201 } │ │ │ │ │ -202 │ │ │ │ │ -_2_0_4 [[nodiscard]] constexpr static _i_n_d_e_x___s_e_q_u_e_n_c_e _e_n_u_m_e_r_a_t_e() │ │ │ │ │ -205 { │ │ │ │ │ -206 return {}; │ │ │ │ │ -207 } │ │ │ │ │ -208 │ │ │ │ │ -_2_1_0 [[nodiscard]] constexpr static std::size_t _s_i_z_e() │ │ │ │ │ -211 { │ │ │ │ │ -212 return sizeof...(T); │ │ │ │ │ -213 } │ │ │ │ │ -214 │ │ │ │ │ -_2_1_6 [[nodiscard]] constexpr static std::size_t _m_a_x___s_i_z_e() │ │ │ │ │ -217 { │ │ │ │ │ -218 return _s_i_z_e(); │ │ │ │ │ -219 } │ │ │ │ │ -220 │ │ │ │ │ -222 template i),bool> = true> │ │ │ │ │ -_2_2_4 [[nodiscard]] constexpr auto _o_p_e_r_a_t_o_r_[_](Dune::index_constant) const │ │ │ │ │ -225 { │ │ │ │ │ -226 return std::get(_data); │ │ │ │ │ -227 } │ │ │ │ │ -228 │ │ │ │ │ -_2_3_0 [[nodiscard]] constexpr std::size_t _o_p_e_r_a_t_o_r_[_](std::size_t pos) const │ │ │ │ │ -231 { │ │ │ │ │ -232 std::size_t entry = 0; │ │ │ │ │ -233 Dune::Hybrid::forEach(_e_n_u_m_e_r_a_t_e(), [&] (auto i) { │ │ │ │ │ -234 if (i==pos) │ │ │ │ │ -235 entry = this->_e_l_e_m_e_n_t(i); │ │ │ │ │ -236 }); │ │ │ │ │ -237 return entry; │ │ │ │ │ -238 } │ │ │ │ │ -239 │ │ │ │ │ -241 template i),bool> = true> │ │ │ │ │ -_2_4_3 [[nodiscard]] constexpr auto _e_l_e_m_e_n_t(Dune::index_constant pos = {}) │ │ │ │ │ -const │ │ │ │ │ -244 { │ │ │ │ │ -245 return std::get(_data); │ │ │ │ │ -246 } │ │ │ │ │ -247 │ │ │ │ │ -_2_4_9 [[nodiscard]] constexpr std::size_t _e_l_e_m_e_n_t(std::size_t pos) const │ │ │ │ │ -250 { │ │ │ │ │ -251 std::size_t entry = 0; │ │ │ │ │ -252 Dune::Hybrid::forEach(_e_n_u_m_e_r_a_t_e(), [&] (auto i) { │ │ │ │ │ -253 if (i==pos) │ │ │ │ │ -254 entry = this->_e_l_e_m_e_n_t(i); │ │ │ │ │ -255 }); │ │ │ │ │ -256 return entry; │ │ │ │ │ -257 } │ │ │ │ │ -258 │ │ │ │ │ -260 template 0 && n == sizeof...(T)),bool> = true> │ │ │ │ │ -_2_6_2 [[nodiscard]] constexpr auto _f_r_o_n_t() const │ │ │ │ │ -263 { │ │ │ │ │ -264 return std::get<0>(_data); │ │ │ │ │ -265 } │ │ │ │ │ -266 │ │ │ │ │ -268 template 0 && n == sizeof...(T)),bool> = true> │ │ │ │ │ -_2_7_0 [[nodiscard]] constexpr auto _b_a_c_k() const │ │ │ │ │ -271 { │ │ │ │ │ -272 return std::get(_data); │ │ │ │ │ -273 } │ │ │ │ │ -274 │ │ │ │ │ -275#ifndef DOXYGEN │ │ │ │ │ -276 │ │ │ │ │ -277 // I can't be bothered to make all the external accessors friends of │ │ │ │ │ -HybridTreePath, │ │ │ │ │ -278 // so we'll only hide the data tuple from the user in Doxygen. │ │ │ │ │ -279 │ │ │ │ │ -280 using Data = std::tuple; │ │ │ │ │ -281 Data _data; │ │ │ │ │ -282 │ │ │ │ │ -283#endif // DOXYGEN │ │ │ │ │ -284 │ │ │ │ │ -285 }; │ │ │ │ │ -286 │ │ │ │ │ -288 │ │ │ │ │ -294 template │ │ │ │ │ -_2_9_5 [[nodiscard]] constexpr auto _m_a_k_e_T_r_e_e_P_a_t_h(const T... t) │ │ │ │ │ -296 { │ │ │ │ │ -297 // check that all entries are based on std::size_t │ │ │ │ │ -298 static_assert((... && Impl::check_size_t()), │ │ │ │ │ -299 "HybridTreePath indices must be of type std::size_t or std:: │ │ │ │ │ -integral_constant"); │ │ │ │ │ -300 return _H_y_b_r_i_d_T_r_e_e_P_a_t_h(t...); │ │ │ │ │ -301 } │ │ │ │ │ -302 │ │ │ │ │ -304 │ │ │ │ │ -311 template │ │ │ │ │ -_3_1_2 [[nodiscard]] constexpr auto _h_y_b_r_i_d_T_r_e_e_P_a_t_h(const T&... t) │ │ │ │ │ -313 { │ │ │ │ │ -314 return _m_a_k_e_T_r_e_e_P_a_t_h(Impl::cast_size_t(t)...); │ │ │ │ │ -315 } │ │ │ │ │ -316 │ │ │ │ │ -318 │ │ │ │ │ -325 template │ │ │ │ │ -_3_2_6 [[nodiscard]] constexpr auto _t_r_e_e_P_a_t_h(const T&... t) │ │ │ │ │ -327 { │ │ │ │ │ -328 return _m_a_k_e_T_r_e_e_P_a_t_h(Impl::cast_size_t(t)...); │ │ │ │ │ -329 } │ │ │ │ │ -330 │ │ │ │ │ -331 │ │ │ │ │ -333 template │ │ │ │ │ -_3_3_4 [[nodiscard]] constexpr std::size_t _t_r_e_e_P_a_t_h_S_i_z_e(const │ │ │ │ │ -_H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>&) │ │ │ │ │ -335 { │ │ │ │ │ -336 return sizeof...(T); │ │ │ │ │ -337 } │ │ │ │ │ -338 │ │ │ │ │ -340 │ │ │ │ │ -356 template │ │ │ │ │ -_3_5_7 [[nodiscard]] constexpr auto _t_r_e_e_P_a_t_h_E_n_t_r_y(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp, │ │ │ │ │ -index_constant = {}) │ │ │ │ │ -358 -> typename std::decay(tp._data))>::type │ │ │ │ │ -359 { │ │ │ │ │ -360 return std::get(tp._data); │ │ │ │ │ -361 } │ │ │ │ │ -362 │ │ │ │ │ -364 │ │ │ │ │ -379 template │ │ │ │ │ -_3_8_0 [[nodiscard]] constexpr std::size_t _t_r_e_e_P_a_t_h_I_n_d_e_x(const │ │ │ │ │ -_H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp, index_constant = {}) │ │ │ │ │ -381 { │ │ │ │ │ -382 return std::get(tp._data); │ │ │ │ │ -383 } │ │ │ │ │ -384 │ │ │ │ │ -386 │ │ │ │ │ -391 template │ │ │ │ │ -_3_9_2 [[nodiscard]] constexpr auto _b_a_c_k(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp) │ │ │ │ │ -393 -> decltype(tp._b_a_c_k()) │ │ │ │ │ -394 { │ │ │ │ │ -395 return tp._b_a_c_k(); │ │ │ │ │ -396 } │ │ │ │ │ -397 │ │ │ │ │ -399 │ │ │ │ │ -404 template │ │ │ │ │ -_4_0_5 [[nodiscard]] constexpr auto _f_r_o_n_t(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp) │ │ │ │ │ -406 -> decltype(tp._f_r_o_n_t()) │ │ │ │ │ -407 { │ │ │ │ │ -408 return tp._f_r_o_n_t(); │ │ │ │ │ -409 } │ │ │ │ │ -410 │ │ │ │ │ -412 │ │ │ │ │ -415 template │ │ │ │ │ -_4_1_6 [[nodiscard]] constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h _p_u_s_h___b_a_c_k(const │ │ │ │ │ -_H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp, std::size_t i) │ │ │ │ │ -417 { │ │ │ │ │ -418 return _H_y_b_r_i_d_T_r_e_e_P_a_t_h(std::tuple_cat(tp._data,std:: │ │ │ │ │ -make_tuple(i))); │ │ │ │ │ -419 } │ │ │ │ │ -420 │ │ │ │ │ -422 │ │ │ │ │ -436 template │ │ │ │ │ -_4_3_7 [[nodiscard]] constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h> _p_u_s_h___b_a_c_k │ │ │ │ │ -(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp, index_constant i_ = {}) │ │ │ │ │ -438 { │ │ │ │ │ -439 return HybridTreePath >(std::tuple_cat │ │ │ │ │ -(tp._data,std::make_tuple(i_))); │ │ │ │ │ -440 } │ │ │ │ │ -441 │ │ │ │ │ -443 │ │ │ │ │ -446 template │ │ │ │ │ -_4_4_7 [[nodiscard]] constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h _p_u_s_h___f_r_o_n_t(const │ │ │ │ │ -_H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp, std::size_t element) │ │ │ │ │ -448 { │ │ │ │ │ -449 return _H_y_b_r_i_d_T_r_e_e_P_a_t_h(std::tuple_cat(std::make_tuple │ │ │ │ │ -(element),tp._data)); │ │ │ │ │ -450 } │ │ │ │ │ -451 │ │ │ │ │ -453 │ │ │ │ │ -467 template │ │ │ │ │ -_4_6_8 [[nodiscard]] constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_i_n_d_e_x___c_o_n_s_t_a_n_t_<_i_>,T...> _p_u_s_h___f_r_o_n_t │ │ │ │ │ -(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp, index_constant _i = {}) │ │ │ │ │ -469 { │ │ │ │ │ -470 return HybridTreePath,T...>(std::tuple_cat(std:: │ │ │ │ │ -make_tuple(_i),tp._data)); │ │ │ │ │ -471 } │ │ │ │ │ -472 │ │ │ │ │ -474 │ │ │ │ │ -485 template │ │ │ │ │ -0),bool> = true> │ │ │ │ │ -_4_8_6 [[nodiscard]] constexpr auto _a_c_c_u_m_u_l_a_t_e___b_a_c_k(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& │ │ │ │ │ -tp, I i) { │ │ │ │ │ -487 using ::Dune::Hybrid::plus; │ │ │ │ │ -488 return _p_u_s_h___b_a_c_k(_p_o_p___b_a_c_k(tp), _p_l_u_s(_b_a_c_k(tp), i)); │ │ │ │ │ -489 } │ │ │ │ │ -490 │ │ │ │ │ -491 │ │ │ │ │ -493 │ │ │ │ │ -504 template │ │ │ │ │ -0),bool> = true> │ │ │ │ │ -_5_0_5 [[nodiscard]] constexpr auto _a_c_c_u_m_u_l_a_t_e___f_r_o_n_t(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& │ │ │ │ │ -tp, I i) { │ │ │ │ │ -506 using ::Dune::Hybrid::plus; │ │ │ │ │ -507 return _p_u_s_h___f_r_o_n_t(_p_o_p___f_r_o_n_t(tp), _p_l_u_s(_f_r_o_n_t(tp), i)); │ │ │ │ │ -508 } │ │ │ │ │ -509 │ │ │ │ │ -511 template │ │ │ │ │ -_5_1_2 [[nodiscard]] constexpr auto _j_o_i_n(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_H_e_a_d_._._._>& head, │ │ │ │ │ -const Other&... tail) { │ │ │ │ │ -513 return _T_y_p_e_T_r_e_e_:_:_H_y_b_r_i_d_T_r_e_e_P_a_t_h{std::tuple_cat(head._data, tail._data...)}; │ │ │ │ │ -514 } │ │ │ │ │ -515 │ │ │ │ │ -517 template │ │ │ │ │ -_5_1_8 [[nodiscard]] constexpr auto _r_e_v_e_r_s_e(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp) { │ │ │ │ │ -519 constexpr std::size_t size = sizeof...(T); │ │ │ │ │ -520 return unpackIntegerSequence([&](auto... i){ │ │ │ │ │ -521 return _t_r_e_e_P_a_t_h(tp[index_constant{}] ...); │ │ │ │ │ -522 }, std::make_index_sequence{}); │ │ │ │ │ -523 } │ │ │ │ │ -524 │ │ │ │ │ -526 │ │ │ │ │ -529 template 0),bool> = true> │ │ │ │ │ -_5_3_0 [[nodiscard]] constexpr auto _p_o_p___f_r_o_n_t(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp) │ │ │ │ │ -531 { │ │ │ │ │ -532 return unpackIntegerSequence([&](auto... i){ │ │ │ │ │ -533 return _H_y_b_r_i_d_T_r_e_e_P_a_t_h{std::make_tuple(std::get(tp._data)...)}; │ │ │ │ │ -534 }, std::make_index_sequence<(sizeof...(T) - 1)>{}); │ │ │ │ │ -535 } │ │ │ │ │ -536 │ │ │ │ │ -538 │ │ │ │ │ -541 template 0),bool> = true> │ │ │ │ │ -_5_4_2 [[nodiscard]] constexpr auto _p_o_p___b_a_c_k(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp) │ │ │ │ │ -543 { │ │ │ │ │ -544 return unpackIntegerSequence([&](auto... i){ │ │ │ │ │ -545 return _H_y_b_r_i_d_T_r_e_e_P_a_t_h{std::make_tuple(std::get(tp._data)...)}; │ │ │ │ │ -546 }, std::make_index_sequence<(sizeof...(T) - 1)>{}); │ │ │ │ │ -547 } │ │ │ │ │ -548 │ │ │ │ │ -550 │ │ │ │ │ -558 template │ │ │ │ │ -_5_5_9 [[nodiscard]] constexpr bool _o_p_e_r_a_t_o_r_=_=( │ │ │ │ │ -560 const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_S_._._._>& lhs, │ │ │ │ │ -561 const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& rhs) │ │ │ │ │ -562 { │ │ │ │ │ -563 if constexpr (sizeof...(S) == sizeof...(T)) { │ │ │ │ │ -564 if constexpr ((Dune::IsInteroperable::value &&...)) { │ │ │ │ │ -565 return unpackIntegerSequence([&](auto... i){ │ │ │ │ │ -566 return ((std::get(lhs._data) == std::get(rhs._data)) &&...); │ │ │ │ │ -567 }, std::make_index_sequence<(sizeof...(S))>{}); │ │ │ │ │ -568 } else { │ │ │ │ │ -569 return false; │ │ │ │ │ -570 } │ │ │ │ │ -571 } else { │ │ │ │ │ -572 return false; │ │ │ │ │ -573 } │ │ │ │ │ -574 } │ │ │ │ │ -575 │ │ │ │ │ -577 │ │ │ │ │ -582 template │ │ │ │ │ -_5_8_3 [[nodiscard]] constexpr auto _o_p_e_r_a_t_o_r_=_=( │ │ │ │ │ -584 const _H_y_b_r_i_d_T_r_e_e_P_a_t_h...>&, │ │ │ │ │ -585 const _H_y_b_r_i_d_T_r_e_e_P_a_t_h...>&) │ │ │ │ │ -586 { │ │ │ │ │ -587 return std::bool_constant<_h_y_b_r_i_d_T_r_e_e_P_a_t_h(lhs...) == _h_y_b_r_i_d_T_r_e_e_P_a_t_h(rhs...)> │ │ │ │ │ -{}; │ │ │ │ │ -588 } │ │ │ │ │ -589 │ │ │ │ │ -590 │ │ │ │ │ -592 template │ │ │ │ │ -_5_9_3 [[nodiscard]] constexpr auto _o_p_e_r_a_t_o_r_!_=( │ │ │ │ │ -594 const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_S_._._._>& lhs, │ │ │ │ │ -595 const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& rhs) │ │ │ │ │ -596 { │ │ │ │ │ -597 return !(lhs == rhs); │ │ │ │ │ -598 } │ │ │ │ │ -599 │ │ │ │ │ -601 template │ │ │ │ │ -_6_0_2 [[nodiscard]] constexpr auto _o_p_e_r_a_t_o_r_!_=( │ │ │ │ │ -603 const _H_y_b_r_i_d_T_r_e_e_P_a_t_h...>&, │ │ │ │ │ -604 const _H_y_b_r_i_d_T_r_e_e_P_a_t_h...>&) │ │ │ │ │ -605 { │ │ │ │ │ -606 return std::bool_constant<_h_y_b_r_i_d_T_r_e_e_P_a_t_h(lhs...) != _h_y_b_r_i_d_T_r_e_e_P_a_t_h(rhs...)> │ │ │ │ │ -{}; │ │ │ │ │ -607 } │ │ │ │ │ -608 │ │ │ │ │ -609 │ │ │ │ │ -_6_1_0 inline namespace Literals { │ │ │ │ │ -611 │ │ │ │ │ -613 │ │ │ │ │ -617 template │ │ │ │ │ -_6_1_8 constexpr auto operator"" _tp() │ │ │ │ │ -619 { │ │ │ │ │ -620 using namespace Dune::Indices::Literals; │ │ │ │ │ -621 return _h_y_b_r_i_d_T_r_e_e_P_a_t_h(operator""_ic()); │ │ │ │ │ -622 } │ │ │ │ │ -623 │ │ │ │ │ -624 } // end namespace Literals │ │ │ │ │ -625 │ │ │ │ │ -626 │ │ │ │ │ -627 template │ │ │ │ │ -_6_2_8 struct _T_r_e_e_P_a_t_h_S_i_z_e<_H_y_b_r_i_d_T_r_e_e_P_a_t_h...> > │ │ │ │ │ -629 : public index_constant │ │ │ │ │ -630 {}; │ │ │ │ │ -631 │ │ │ │ │ -632 │ │ │ │ │ -633 template │ │ │ │ │ -_6_3_4 struct _T_r_e_e_P_a_t_h_P_u_s_h_B_a_c_k<_H_y_b_r_i_d_T_r_e_e_P_a_t_h...>,k> │ │ │ │ │ -635 { │ │ │ │ │ -_6_3_6 typedef _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_i_n_d_e_x___c_o_n_s_t_a_n_t_<_i_>...,index_constant> _t_y_p_e; │ │ │ │ │ -637 }; │ │ │ │ │ -638 │ │ │ │ │ -639 template │ │ │ │ │ -_6_4_0 struct _T_r_e_e_P_a_t_h_P_u_s_h_F_r_o_n_t<_H_y_b_r_i_d_T_r_e_e_P_a_t_h...>,k> │ │ │ │ │ -641 { │ │ │ │ │ -_6_4_2 typedef _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_i_n_d_e_x___c_o_n_s_t_a_n_t_<_k_>,index_constant...> _t_y_p_e; │ │ │ │ │ -643 }; │ │ │ │ │ -644 │ │ │ │ │ -645 template │ │ │ │ │ -_6_4_6 struct _T_r_e_e_P_a_t_h_B_a_c_k<_H_y_b_r_i_d_T_r_e_e_P_a_t_h>> │ │ │ │ │ -647 : public index_constant │ │ │ │ │ -648 {}; │ │ │ │ │ -649 │ │ │ │ │ -650 template │ │ │ │ │ -_6_5_1 struct │ │ │ │ │ -_T_r_e_e_P_a_t_h_B_a_c_k<_H_y_b_r_i_d_T_r_e_e_P_a_t_h,index_constant,index_constant...>> │ │ │ │ │ -652 : public │ │ │ │ │ -_T_r_e_e_P_a_t_h_B_a_c_k,index_constant...>> │ │ │ │ │ -653 {}; │ │ │ │ │ -654 │ │ │ │ │ -655 template │ │ │ │ │ -_6_5_6 struct │ │ │ │ │ -_T_r_e_e_P_a_t_h_F_r_o_n_t<_H_y_b_r_i_d_T_r_e_e_P_a_t_h,index_constant...>> │ │ │ │ │ -657 : public index_constant │ │ │ │ │ -658 {}; │ │ │ │ │ -659 │ │ │ │ │ -660 template │ │ │ │ │ -_6_6_1 struct _T_r_e_e_P_a_t_h_P_o_p_B_a_c_k<_H_y_b_r_i_d_T_r_e_e_P_a_t_h>,i...> │ │ │ │ │ -662 { │ │ │ │ │ -_6_6_3 typedef _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_i_n_d_e_x___c_o_n_s_t_a_n_t_<_i_>...> _t_y_p_e; │ │ │ │ │ -664 }; │ │ │ │ │ -665 │ │ │ │ │ -666 template │ │ │ │ │ -_6_7_0 struct │ │ │ │ │ -_T_r_e_e_P_a_t_h_P_o_p_B_a_c_k<_H_y_b_r_i_d_T_r_e_e_P_a_t_h,index_constant,index_constant...>,i...> │ │ │ │ │ -671 : public │ │ │ │ │ -_T_r_e_e_P_a_t_h_P_o_p_B_a_c_k,index_constant...>,i...,j> │ │ │ │ │ -672 {}; │ │ │ │ │ -673 │ │ │ │ │ -674 template │ │ │ │ │ -_6_7_5 struct │ │ │ │ │ -_T_r_e_e_P_a_t_h_P_o_p_F_r_o_n_t<_H_y_b_r_i_d_T_r_e_e_P_a_t_h,index_constant...> > │ │ │ │ │ -676 { │ │ │ │ │ -_6_7_7 typedef _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_i_n_d_e_x___c_o_n_s_t_a_n_t_<_i_>...> _t_y_p_e; │ │ │ │ │ -678 }; │ │ │ │ │ -679 │ │ │ │ │ -680 template │ │ │ │ │ -_6_8_1 struct │ │ │ │ │ -_T_r_e_e_P_a_t_h_C_o_n_c_a_t<_H_y_b_r_i_d_T_r_e_e_P_a_t_h...>,_H_y_b_r_i_d_T_r_e_e_P_a_t_h...> │ │ │ │ │ -> │ │ │ │ │ -682 { │ │ │ │ │ -_6_8_3 typedef _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_i_n_d_e_x___c_o_n_s_t_a_n_t_<_i_>...,index_constant...> _t_y_p_e; │ │ │ │ │ -684 }; │ │ │ │ │ -685 │ │ │ │ │ -686#ifndef DOXYGEN │ │ │ │ │ -687 │ │ │ │ │ -688 namespace impl { │ │ │ │ │ -689 │ │ │ │ │ -690 // end of recursion │ │ │ │ │ -691 template │ │ │ │ │ -692 typename std::enable_if< │ │ │ │ │ -693 (i == sizeof...(T)) │ │ │ │ │ -694 >::type │ │ │ │ │ -695 print_hybrid_tree_path(std::ostream& os, const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp, │ │ │ │ │ -index_constant _i) │ │ │ │ │ -696 {} │ │ │ │ │ -697 │ │ │ │ │ -698 // print current entry and recurse │ │ │ │ │ -699 template │ │ │ │ │ -700 typename std::enable_if< │ │ │ │ │ -701 (i < sizeof...(T)) │ │ │ │ │ -702 >::type │ │ │ │ │ -703 print_hybrid_tree_path(std::ostream& os, const HybridTreePath& tp, │ │ │ │ │ -index_constant _i) │ │ │ │ │ -704 { │ │ │ │ │ -705 os << _t_r_e_e_P_a_t_h_I_n_d_e_x(tp,_i) << " "; │ │ │ │ │ -706 print_hybrid_tree_path(os,tp,index_constant{}); │ │ │ │ │ -707 } │ │ │ │ │ -708 │ │ │ │ │ -709 } // namespace impl │ │ │ │ │ -710 │ │ │ │ │ -711#endif // DOXYGEN │ │ │ │ │ -712 │ │ │ │ │ -714 template │ │ │ │ │ -_7_1_5 std::ostream& _o_p_e_r_a_t_o_r_<_<(std::ostream& os, const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp) │ │ │ │ │ -716 { │ │ │ │ │ -717 os << "HybridTreePath< "; │ │ │ │ │ -718 impl::print_hybrid_tree_path(os, tp, index_constant<0>{}); │ │ │ │ │ -719 os << ">"; │ │ │ │ │ -720 return os; │ │ │ │ │ -721 } │ │ │ │ │ -722 │ │ │ │ │ -723 template │ │ │ │ │ -_7_2_4 using _S_t_a_t_i_c_T_r_e_e_P_a_t_h = _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_D_u_n_e_:_:_i_n_d_e_x___c_o_n_s_t_a_n_t_<_i_>...>; │ │ │ │ │ -725 │ │ │ │ │ -727 │ │ │ │ │ -728 } // namespace TypeTree │ │ │ │ │ -729} //namespace Dune │ │ │ │ │ -730 │ │ │ │ │ -731#endif // DUNE_TYPETREE_TREEPATH_HH │ │ │ │ │ -_f_i_x_e_d_c_a_p_a_c_i_t_y_s_t_a_c_k_._h_h │ │ │ │ │ -_u_t_i_l_i_t_y_._h_h │ │ │ │ │ -_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_:_:_o_p_e_r_a_t_o_r_<_< │ │ │ │ │ -std::ostream & operator<<(std::ostream &os, const HybridTreePath< T... > &tp) │ │ │ │ │ -Dumps a HybridTreePath to a stream. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:715 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_t_r_e_e_P_a_t_h_S_i_z_e │ │ │ │ │ -constexpr std::size_t treePathSize(const HybridTreePath< T... > &) │ │ │ │ │ -Returns the size (number of components) of the given HybridTreePath. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:334 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_b_a_c_k │ │ │ │ │ -constexpr auto back(const HybridTreePath< T... > &tp) -> decltype(tp.back()) │ │ │ │ │ -Returns a copy of the last element of the HybridTreePath. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:392 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_u_s_h___f_r_o_n_t │ │ │ │ │ -constexpr HybridTreePath< std::size_t, T... > push_front(const HybridTreePath< │ │ │ │ │ -T... > &tp, std::size_t element) │ │ │ │ │ -Prepends a run time index to a HybridTreePath. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:447 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_c_c_u_m_u_l_a_t_e___f_r_o_n_t │ │ │ │ │ -constexpr auto accumulate_front(const HybridTreePath< T... > &tp, I i) │ │ │ │ │ -Hybrid utility that accumulates to the front of a multi-index. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:505 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_o_p___f_r_o_n_t │ │ │ │ │ -constexpr auto pop_front(const HybridTreePath< T... > &tp) │ │ │ │ │ -Removes first index on a HybridTreePath. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:530 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_r_e_v_e_r_s_e │ │ │ │ │ -constexpr auto reverse(const HybridTreePath< T... > &tp) │ │ │ │ │ -Reverses the order of the elements in the path. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:518 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_c_c_u_m_u_l_a_t_e___b_a_c_k │ │ │ │ │ -constexpr auto accumulate_back(const HybridTreePath< T... > &tp, I i) │ │ │ │ │ -Hybrid utility that accumulates to the back of a multi-index. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:486 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_j_o_i_n │ │ │ │ │ -constexpr auto join(const HybridTreePath< Head... > &head, const Other &... │ │ │ │ │ -tail) │ │ │ │ │ -Join two tree paths into one. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:512 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_t_r_e_e_P_a_t_h_E_n_t_r_y │ │ │ │ │ -constexpr auto treePathEntry(const HybridTreePath< T... > &tp, index_constant< │ │ │ │ │ -i >={}) -> typename std::decay< decltype(std::get< i >(tp._data))>::type │ │ │ │ │ -Returns a copy of the i-th element of the HybridTreePath. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:357 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_o_p___b_a_c_k │ │ │ │ │ -constexpr auto pop_back(const HybridTreePath< T... > &tp) │ │ │ │ │ -Removes last index on a HybridTreePath. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:542 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_p_e_r_a_t_o_r_!_= │ │ │ │ │ -constexpr auto operator!=(const HybridTreePath< S... > &lhs, const │ │ │ │ │ -HybridTreePath< T... > &rhs) │ │ │ │ │ -Compare two HybridTreePaths for unequality. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:593 │ │ │ │ │ -_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 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_t_r_e_e_P_a_t_h_I_n_d_e_x │ │ │ │ │ -constexpr std::size_t treePathIndex(const HybridTreePath< T... > &tp, │ │ │ │ │ -index_constant< i >={}) │ │ │ │ │ -Returns the index value of the i-th element of the HybridTreePath. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:380 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_a_k_e_T_r_e_e_P_a_t_h │ │ │ │ │ -constexpr auto makeTreePath(const T... t) │ │ │ │ │ -helper function to construct a new HybridTreePath from the given indices. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:295 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_p_e_r_a_t_o_r_=_= │ │ │ │ │ -constexpr bool operator==(const HybridTreePath< S... > &lhs, const │ │ │ │ │ -HybridTreePath< T... > &rhs) │ │ │ │ │ -Compare two HybridTreePaths for value equality. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:559 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_r_i_n_t___t_r_e_e___p_a_t_h │ │ │ │ │ -void print_tree_path(std::ostream &os) │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:134 │ │ │ │ │ -_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_:_:_T_y_p_e_T_r_e_e_:_:_f_r_o_n_t │ │ │ │ │ -constexpr auto front(const HybridTreePath< T... > &tp) -> decltype(tp.front()) │ │ │ │ │ -Returns a copy of the first element of the HybridTreePath. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:405 │ │ │ │ │ +5#ifndef DUNE_TYPETREE_EXCEPTIONS_HH │ │ │ │ │ +6#define DUNE_TYPETREE_EXCEPTIONS_HH │ │ │ │ │ +7 │ │ │ │ │ +8#include │ │ │ │ │ +9 │ │ │ │ │ +15namespace _D_u_n_e { │ │ │ │ │ +16 namespace TypeTree { │ │ │ │ │ +17 │ │ │ │ │ +_1_9 class _E_x_c_e_p_t_i_o_n │ │ │ │ │ +20 : public Dune::Exception │ │ │ │ │ +21 {}; │ │ │ │ │ +22 │ │ │ │ │ +23 } // namespace TypeTree │ │ │ │ │ +24} // namespace Dune │ │ │ │ │ +25 │ │ │ │ │ +26#endif // DUNE_TYPETREE_EXCEPTIONS_HH │ │ │ │ │ _D_u_n_e │ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_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_:_:_f_u_l_l_y_S_t_a_t_i_c │ │ │ │ │ -@ fullyStatic │ │ │ │ │ -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 │ │ │ │ │ -_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_:_:_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_:_:_H_y_b_r_i_d_T_r_e_e_P_a_t_h_:_:_H_y_b_r_i_d_T_r_e_e_P_a_t_h │ │ │ │ │ -constexpr HybridTreePath(HybridTreePath &&tp)=default │ │ │ │ │ -_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_:_:_b_a_c_k │ │ │ │ │ -constexpr auto back() const │ │ │ │ │ -Get the last index value. Only available in non-empty paths. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:270 │ │ │ │ │ -_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_:_:_o_p_e_r_a_t_o_r_= │ │ │ │ │ -constexpr HybridTreePath & operator=(const HybridTreePath &tp)=default │ │ │ │ │ -_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_:_:_e_l_e_m_e_n_t │ │ │ │ │ -constexpr std::size_t element(std::size_t pos) const │ │ │ │ │ -Get the index value at position pos. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:249 │ │ │ │ │ -_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_:_:_H_y_b_r_i_d_T_r_e_e_P_a_t_h │ │ │ │ │ -constexpr HybridTreePath(std::tuple< T... > t) │ │ │ │ │ -Constructor from a std::tuple │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:186 │ │ │ │ │ -_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_:_:_o_p_e_r_a_t_o_r_= │ │ │ │ │ -constexpr HybridTreePath & operator=(HybridTreePath &&tp)=default │ │ │ │ │ -_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_:_:_H_y_b_r_i_d_T_r_e_e_P_a_t_h │ │ │ │ │ -constexpr HybridTreePath(U... t) │ │ │ │ │ -Constructor from arguments. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:196 │ │ │ │ │ -_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_:_:_H_y_b_r_i_d_T_r_e_e_P_a_t_h │ │ │ │ │ -constexpr HybridTreePath() │ │ │ │ │ -Default constructor. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:173 │ │ │ │ │ -_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_:_:_e_l_e_m_e_n_t │ │ │ │ │ -constexpr auto element(Dune::index_constant< i > pos={}) const │ │ │ │ │ -Get the last index value. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:243 │ │ │ │ │ -_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_:_:_s_i_z_e │ │ │ │ │ -static constexpr std::size_t size() │ │ │ │ │ -Get the size (length) of this path. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:210 │ │ │ │ │ -_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_:_:_o_p_e_r_a_t_o_r_[_] │ │ │ │ │ -constexpr auto operator[](Dune::index_constant< i >) const │ │ │ │ │ -Get the index value at position pos. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:224 │ │ │ │ │ -_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_:_:_f_r_o_n_t │ │ │ │ │ -constexpr auto front() const │ │ │ │ │ -Get the first index value. Only available in non-empty paths. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:262 │ │ │ │ │ -_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_:_:_e_n_u_m_e_r_a_t_e │ │ │ │ │ -static constexpr index_sequence enumerate() │ │ │ │ │ -Returns an index_sequence for enumerating the components of this │ │ │ │ │ -HybridTreePath. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:204 │ │ │ │ │ -_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_:_:_H_y_b_r_i_d_T_r_e_e_P_a_t_h │ │ │ │ │ -constexpr HybridTreePath(const HybridTreePath &tp)=default │ │ │ │ │ -_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_:_:_o_p_e_r_a_t_o_r_[_] │ │ │ │ │ -constexpr std::size_t operator[](std::size_t pos) const │ │ │ │ │ -Get the index value at position pos. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:230 │ │ │ │ │ -_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_:_:_m_a_x___s_i_z_e │ │ │ │ │ -static constexpr std::size_t max_size() │ │ │ │ │ -Get the size (length) of this path. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:216 │ │ │ │ │ -_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_:_:_i_n_d_e_x___s_e_q_u_e_n_c_e │ │ │ │ │ -std::index_sequence_for< T... > index_sequence │ │ │ │ │ -An index_sequence for the entries in this HybridTreePath. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:170 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_S_i_z_e │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:110 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_u_s_h_B_a_c_k │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:113 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_u_s_h_F_r_o_n_t │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:116 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_B_a_c_k │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:119 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_F_r_o_n_t │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:122 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_o_p_B_a_c_k │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:125 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_o_p_F_r_o_n_t │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:128 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_C_o_n_c_a_t │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:131 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_u_s_h_B_a_c_k_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i_ _>_._._._ _>_,_ _k │ │ │ │ │ -_>_:_:_t_y_p_e │ │ │ │ │ -HybridTreePath< index_constant< i >..., index_constant< k > > type │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:636 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_u_s_h_F_r_o_n_t_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i_ _>_._._._ _>_,_ _k │ │ │ │ │ -_>_:_:_t_y_p_e │ │ │ │ │ -HybridTreePath< index_constant< k >, index_constant< i >... > type │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:642 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_o_p_B_a_c_k_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _>_ _>_,_ _i_._._. │ │ │ │ │ -_>_:_:_t_y_p_e │ │ │ │ │ -HybridTreePath< index_constant< i >... > type │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:663 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_o_p_F_r_o_n_t_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _>_, │ │ │ │ │ -_i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i_ _>_._._._ _>_ _>_:_:_t_y_p_e │ │ │ │ │ -HybridTreePath< index_constant< i >... > type │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:677 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_C_o_n_c_a_t_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i_ _>_._._._ _>_, │ │ │ │ │ -_H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _>_._._._ _>_ _>_:_:_t_y_p_e │ │ │ │ │ -HybridTreePath< index_constant< i >..., index_constant< k >... > type │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:683 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_c_e_p_t_i_o_n │ │ │ │ │ +Base class for all TypeTree exceptions. │ │ │ │ │ +DDeeffiinniittiioonn exceptions.hh:21 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00044.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: typetraits.hh File Reference │ │ │ │ +dune-typetree: compositenode.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -71,100 +71,42 @@ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ Classes | │ │ │ │ -Namespaces | │ │ │ │ -Functions
    │ │ │ │ -
    typetraits.hh File Reference
    │ │ │ │ +Namespaces
    │ │ │ │ +
    compositenode.hh File Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ -
    #include <type_traits>
    │ │ │ │ -#include <dune/common/typetraits.hh>
    │ │ │ │ -#include <dune/typetree/treepath.hh>
    │ │ │ │ -#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ +
    #include <tuple>
    │ │ │ │ +#include <memory>
    │ │ │ │ +#include <type_traits>
    │ │ │ │ +#include <dune/typetree/nodetags.hh>
    │ │ │ │ +#include <dune/typetree/childextraction.hh>
    │ │ │ │ +#include <dune/typetree/typetraits.hh>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  Dune::first_type< T0, T... >
    class  Dune::TypeTree::CompositeNode< Children >
     Base class for composite nodes based on variadic templates. More...
     
    struct  Dune::TypeTree::has_node_tag< T >
     
    struct  Dune::TypeTree::has_node_tag< T >::yes
     
    struct  Dune::TypeTree::has_node_tag< T >::no
     
    struct  Dune::TypeTree::has_node_tag_value< T, V >
     
    struct  Dune::TypeTree::has_node_tag_value< T, V >::maybe< N >
     
    struct  Dune::TypeTree::has_node_tag_value< T, V >::yes
     
    struct  Dune::TypeTree::has_node_tag_value< T, V >::no
     
    struct  Dune::TypeTree::has_implementation_tag< T >
     
    struct  Dune::TypeTree::has_implementation_tag< T >::yes
     
    struct  Dune::TypeTree::has_implementation_tag< T >::no
     
    struct  Dune::TypeTree::has_implementation_tag_value< T, V >
     
    struct  Dune::TypeTree::has_implementation_tag_value< T, V >::maybe< N >
     
    struct  Dune::TypeTree::has_implementation_tag_value< T, V >::yes
     
    struct  Dune::TypeTree::has_implementation_tag_value< T, V >::no
     
    struct  Dune::TypeTree::AlwaysVoid< typename >
     
    struct  Dune::TypeTree::meta_function
     Marker tag declaring a meta function. More...
     
    struct  Dune::TypeTree::lazy_evaluate< F >
     Helper meta function to delay evaluation of F. More...
     
    struct  Dune::TypeTree::lazy_identity< F >
     Identity function. More...
     
    struct  Dune::TypeTree::evaluate_if_meta_function< F >
     Meta function that evaluates its argument iff it inherits from meta_function. More...
     
    struct  Dune::TypeTree::IsTreePath< T >
     Check if type represents a tree path. More...
    struct  Dune::TypeTree::CompositeNode< Children >::Child< k >
     Access to the type and storage type of the i-th child. More...
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ -

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
     
    namespace  Dune::TypeTree::impl
     
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │

    │ │ │ │ -Functions

    template<typename T >
    T * Dune::TypeTree::declptr ()
     Helper function for generating a pointer to a value of type T in an unevaluated operand setting.
     
    constexpr auto Dune::TypeTree::impl::isTreePath (void *) -> std::false_type
     
    template<class... I>
    constexpr auto Dune::TypeTree::impl::isTreePath (const HybridTreePath< I... > *) -> std::true_type
     
    template<class T >
    constexpr auto Dune::TypeTree::isTreePath (const T &) -> IsTreePath< T >
     Check if given object represents a tree path.
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,87 +1,29 @@ │ │ │ │ │ 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 │ │ │ │ │ -typetraits.hh File Reference │ │ │ │ │ +_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s │ │ │ │ │ +compositenode.hh File Reference │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ #include │ │ │ │ │ -#include │ │ │ │ │ -#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_/_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_/_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h> │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_y_p_e_t_r_a_i_t_s_._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_:_:_f_i_r_s_t___t_y_p_e_<_ _T_0_,_ _T_._._._ _> │ │ │ │ │ + class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_<_ _C_h_i_l_d_r_e_n_ _> │ │ │ │ │ +  Base class for composite nodes based on variadic templates. _M_o_r_e_._._. │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_<_ _T_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_<_ _T_ _>_:_:_y_e_s │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_<_ _T_ _>_:_:_n_o │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_<_ _T_,_ _V_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_<_ _T_,_ _V_ _>_:_:_m_a_y_b_e_<_ _N_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_<_ _T_,_ _V_ _>_:_:_y_e_s │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_<_ _T_,_ _V_ _>_:_:_n_o │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_<_ _T_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_<_ _T_ _>_:_:_y_e_s │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_<_ _T_ _>_:_:_n_o │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_<_ _T_,_ _V_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_<_ _T_,_ _V_ _>_:_:_m_a_y_b_e_<_ _N_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_<_ _T_,_ _V_ _>_:_:_y_e_s │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_<_ _T_,_ _V_ _>_:_:_n_o │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_l_w_a_y_s_V_o_i_d_<_ _t_y_p_e_n_a_m_e_ _> │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_e_t_a___f_u_n_c_t_i_o_n │ │ │ │ │ -  Marker tag declaring a meta function. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_l_a_z_y___e_v_a_l_u_a_t_e_<_ _F_ _> │ │ │ │ │ -  Helper meta function to delay evaluation of F. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_l_a_z_y___i_d_e_n_t_i_t_y_<_ _F_ _> │ │ │ │ │ -  Identity function. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_e_v_a_l_u_a_t_e___i_f___m_e_t_a___f_u_n_c_t_i_o_n_<_ _F_ _> │ │ │ │ │ -  Meta function that evaluates its argument iff it inherits from │ │ │ │ │ - _m_e_t_a___f_u_n_c_t_i_o_n. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_I_s_T_r_e_e_P_a_t_h_<_ _T_ _> │ │ │ │ │ -  Check if type represents a tree path. _M_o_r_e_._._. │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_<_ _C_h_i_l_d_r_e_n_ _>_:_:_C_h_i_l_d_<_ _k_ _> │ │ │ │ │ +  Access to the type and storage type of the i-th child. _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_:_:_i_m_p_l │ │ │ │ │ -  │ │ │ │ │ -FFuunnccttiioonnss │ │ │ │ │ -template │ │ │ │ │ - T *  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_d_e_c_l_p_t_r () │ │ │ │ │ -  Helper function for generating a pointer to a value of type T │ │ │ │ │ - in an unevaluated operand setting. │ │ │ │ │ -  │ │ │ │ │ -constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_m_p_l_:_:_i_s_T_r_e_e_P_a_t_h (void *) -> std::false_type │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ -constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_m_p_l_:_:_i_s_T_r_e_e_P_a_t_h (const _H_y_b_r_i_d_T_r_e_e_P_a_t_h< I... > │ │ │ │ │ - *) -> std::true_type │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ -constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_s_T_r_e_e_P_a_t_h (const T &) -> _I_s_T_r_e_e_P_a_t_h< T > │ │ │ │ │ -  Check if given object represents a tree path. │ │ │ │ │ -  │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00044_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: typetraits.hh Source File │ │ │ │ +dune-typetree: compositenode.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,277 +74,267 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -
    typetraits.hh
    │ │ │ │ +
    compositenode.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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_TYPETRAITS_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_TYPETRAITS_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_COMPOSITENODE_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_COMPOSITENODE_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <type_traits>
    │ │ │ │ -
    10#include <dune/common/typetraits.hh>
    │ │ │ │ -
    11
    │ │ │ │ -
    12#include <dune/typetree/treepath.hh>
    │ │ │ │ -
    13#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ -
    14
    │ │ │ │ -
    15namespace Dune {
    │ │ │ │ +
    9#include <tuple>
    │ │ │ │ +
    10#include <memory>
    │ │ │ │ +
    11#include <type_traits>
    │ │ │ │ +
    12
    │ │ │ │ +
    13#include <dune/typetree/nodetags.hh>
    │ │ │ │ +
    14#include <dune/typetree/childextraction.hh>
    │ │ │ │ +
    15#include <dune/typetree/typetraits.hh>
    │ │ │ │
    16
    │ │ │ │ -
    17 // Provide some more C++11 TMP helpers.
    │ │ │ │ -
    18 // These should be upstreamed to dune-common ASAP.
    │ │ │ │ +
    17namespace Dune {
    │ │ │ │ +
    18 namespace TypeTree {
    │ │ │ │
    19
    │ │ │ │ -
    20 template<typename... T>
    │ │ │ │ -
    21 struct first_type;
    │ │ │ │ -
    22
    │ │ │ │ -
    23 template<typename T0, typename... T>
    │ │ │ │ -
    │ │ │ │ -
    24 struct first_type<T0,T...>
    │ │ │ │ -
    25 {
    │ │ │ │ -
    26 typedef T0 type;
    │ │ │ │ -
    27 };
    │ │ │ │ -
    │ │ │ │ -
    28
    │ │ │ │ -
    29 namespace TypeTree {
    │ │ │ │ -
    30
    │ │ │ │ -
    31 template<typename T>
    │ │ │ │ -
    │ │ │ │ -
    32 struct has_node_tag
    │ │ │ │ -
    33 {
    │ │ │ │ -
    34 struct yes { char dummy[1]; };
    │ │ │ │ -
    35 struct no { char dummy[2]; };
    │ │ │ │ -
    36
    │ │ │ │ -
    37 template<typename X>
    │ │ │ │ -
    38 static yes test(NodeTag<X> *);
    │ │ │ │ -
    39 template<typename X>
    │ │ │ │ -
    40 static no test(...);
    │ │ │ │ -
    41
    │ │ │ │ -
    43 constexpr static bool value = sizeof(test<T>(0)) == sizeof(yes);
    │ │ │ │ -
    44 };
    │ │ │ │ -
    │ │ │ │ -
    45
    │ │ │ │ -
    46 template<typename T, typename V>
    │ │ │ │ -
    │ │ │ │ -
    47 struct has_node_tag_value
    │ │ │ │ -
    48 {
    │ │ │ │ -
    49 template<int N>
    │ │ │ │ -
    50 struct maybe { char dummy[N+1]; };
    │ │ │ │ -
    51 struct yes { char dummy[2]; };
    │ │ │ │ -
    52 struct no { char dummy[1]; };
    │ │ │ │ -
    53
    │ │ │ │ -
    54 template<typename X>
    │ │ │ │ -
    55 static maybe<std::is_base_of<V, NodeTag<X>>::value>
    │ │ │ │ -
    56 test(NodeTag<X> * a);
    │ │ │ │ -
    57 template<typename X>
    │ │ │ │ -
    58 static no test(...);
    │ │ │ │ -
    59
    │ │ │ │ -
    61 constexpr static bool value = sizeof(test<T>(0)) == sizeof(yes);
    │ │ │ │ -
    62 };
    │ │ │ │ -
    │ │ │ │ +
    26 template<typename... Children>
    │ │ │ │ +
    │ │ │ │ +
    27 class CompositeNode
    │ │ │ │ +
    28 {
    │ │ │ │ +
    29
    │ │ │ │ +
    30 public:
    │ │ │ │ +
    31
    │ │ │ │ +
    33 typedef CompositeNodeTag NodeTag;
    │ │ │ │ +
    34
    │ │ │ │ +
    36 typedef std::tuple<std::shared_ptr<Children>... > NodeStorage;
    │ │ │ │ +
    37
    │ │ │ │ +
    39 typedef std::tuple<Children...> ChildTypes;
    │ │ │ │ +
    40
    │ │ │ │ +
    42 static const bool isLeaf = false;
    │ │ │ │ +
    43
    │ │ │ │ +
    45 static const bool isPower = false;
    │ │ │ │ +
    46
    │ │ │ │ +
    48 static const bool isComposite = true;
    │ │ │ │ +
    49
    │ │ │ │ +
    │ │ │ │ +
    50 static constexpr auto degree ()
    │ │ │ │ +
    51 {
    │ │ │ │ +
    52 return std::integral_constant<std::size_t,sizeof...(Children)>{};
    │ │ │ │ +
    53 }
    │ │ │ │ +
    │ │ │ │ +
    54
    │ │ │ │ +
    56 template<std::size_t k>
    │ │ │ │ +
    │ │ │ │ +
    57 struct Child {
    │ │ │ │ +
    58
    │ │ │ │ +
    59 static_assert((k < degree()), "child index out of range");
    │ │ │ │ +
    60
    │ │ │ │ +
    62 typedef typename std::tuple_element<k,ChildTypes>::type Type;
    │ │ │ │
    63
    │ │ │ │ -
    64 template<typename T>
    │ │ │ │ -
    │ │ │ │ -
    65 struct has_implementation_tag
    │ │ │ │ -
    66 {
    │ │ │ │ -
    67 struct yes { char dummy[1]; };
    │ │ │ │ -
    68 struct no { char dummy[2]; };
    │ │ │ │ -
    69
    │ │ │ │ -
    70 template<typename X>
    │ │ │ │ -
    71 static yes test(ImplementationTag<X> *);
    │ │ │ │ -
    72 template<typename X>
    │ │ │ │ -
    73 static no test(...);
    │ │ │ │ -
    74
    │ │ │ │ -
    76 constexpr static bool value = sizeof(test<T>(0)) == sizeof(yes);
    │ │ │ │ -
    77 };
    │ │ │ │ -
    │ │ │ │ -
    78
    │ │ │ │ -
    79 template<typename T, typename V>
    │ │ │ │ -
    │ │ │ │ -
    80 struct has_implementation_tag_value
    │ │ │ │ -
    81 {
    │ │ │ │ -
    82 template<int N>
    │ │ │ │ -
    83 struct maybe { char dummy[N+1]; };
    │ │ │ │ -
    84 struct yes { char dummy[2]; };
    │ │ │ │ -
    85 struct no { char dummy[1]; };
    │ │ │ │ -
    86
    │ │ │ │ -
    87 template<typename X>
    │ │ │ │ -
    88 static maybe<std::is_base_of<V, ImplementationTag<X>>::value>
    │ │ │ │ -
    89 test(ImplementationTag<X> * a);
    │ │ │ │ -
    90 template<typename X>
    │ │ │ │ -
    91 static no test(...);
    │ │ │ │ -
    92
    │ │ │ │ -
    94 constexpr static bool value = sizeof(test<T>(0)) == sizeof(yes);
    │ │ │ │ -
    95 };
    │ │ │ │ +
    65 typedef typename std::tuple_element<k,ChildTypes>::type type;
    │ │ │ │ +
    66 };
    │ │ │ │
    │ │ │ │ -
    96
    │ │ │ │ -
    97 template<typename>
    │ │ │ │ -
    │ │ │ │ -
    98 struct AlwaysVoid
    │ │ │ │ -
    99 {
    │ │ │ │ -
    100 typedef void type;
    │ │ │ │ -
    101 };
    │ │ │ │ +
    67
    │ │ │ │ +
    70
    │ │ │ │ +
    72
    │ │ │ │ +
    75 template<std::size_t k>
    │ │ │ │ +
    │ │ │ │ +
    76 typename Child<k>::Type& child (index_constant<k> = {})
    │ │ │ │ +
    77 {
    │ │ │ │ +
    78 return *std::get<k>(_children);
    │ │ │ │ +
    79 }
    │ │ │ │ +
    │ │ │ │ +
    80
    │ │ │ │ +
    82
    │ │ │ │ +
    85 template<std::size_t k>
    │ │ │ │ +
    │ │ │ │ +
    86 const typename Child<k>::Type& child (index_constant<k> = {}) const
    │ │ │ │ +
    87 {
    │ │ │ │ +
    88 return *std::get<k>(_children);
    │ │ │ │ +
    89 }
    │ │ │ │ +
    │ │ │ │ +
    90
    │ │ │ │ +
    92
    │ │ │ │ +
    95 template<std::size_t k>
    │ │ │ │ +
    │ │ │ │ +
    96 std::shared_ptr<typename Child<k>::Type> childStorage (index_constant<k> = {})
    │ │ │ │ +
    97 {
    │ │ │ │ +
    98 return std::get<k>(_children);
    │ │ │ │ +
    99 }
    │ │ │ │
    │ │ │ │ +
    100
    │ │ │ │
    102
    │ │ │ │ -
    103
    │ │ │ │ -
    105 template<typename T>
    │ │ │ │ -
    106 T* declptr();
    │ │ │ │ -
    107
    │ │ │ │ -
    108
    │ │ │ │ -
    109 // Support for lazy evaluation of meta functions. This is required when doing
    │ │ │ │ -
    110 // nested tag dispatch without C++11-style typedefs (based on using syntax).
    │ │ │ │ -
    111 // The standard struct-based meta functions cause premature evaluation in a
    │ │ │ │ -
    112 // context that is not SFINAE-compatible. We thus have to return the meta function
    │ │ │ │ -
    113 // without evaluating it, placing that burden on the caller. On the other hand,
    │ │ │ │ -
    114 // the lookup will often directly be the target type, so here is some helper code
    │ │ │ │ -
    115 // to automatically do the additional evaluation if necessary.
    │ │ │ │ -
    116 // Too bad that the new syntax is GCC 4.6+...
    │ │ │ │ +
    105 template<std::size_t k>
    │ │ │ │ +
    │ │ │ │ +
    106 std::shared_ptr<const typename Child<k>::Type> childStorage (index_constant<k> = {}) const
    │ │ │ │ +
    107 {
    │ │ │ │ +
    108 return std::get<k>(_children);
    │ │ │ │ +
    109 }
    │ │ │ │ +
    │ │ │ │ +
    110
    │ │ │ │ +
    112 template<std::size_t k>
    │ │ │ │ +
    │ │ │ │ +
    113 void setChild (typename Child<k>::Type& child, index_constant<k> = {})
    │ │ │ │ +
    114 {
    │ │ │ │ +
    115 std::get<k>(_children) = stackobject_to_shared_ptr(child);
    │ │ │ │ +
    116 }
    │ │ │ │ +
    │ │ │ │
    117
    │ │ │ │ -
    118
    │ │ │ │ -
    120
    │ │ │ │ -
    123 struct meta_function {};
    │ │ │ │ +
    119 template<std::size_t k>
    │ │ │ │ +
    │ │ │ │ +
    120 void setChild (typename Child<k>::Type&& child, index_constant<k> = {})
    │ │ │ │ +
    121 {
    │ │ │ │ +
    122 std::get<k>(_children) = convert_arg(std::move(child));
    │ │ │ │ +
    123 }
    │ │ │ │ +
    │ │ │ │
    124
    │ │ │ │ -
    126 template<typename F>
    │ │ │ │ -
    │ │ │ │ -
    127 struct lazy_evaluate
    │ │ │ │ -
    128 {
    │ │ │ │ -
    129 typedef typename F::type type;
    │ │ │ │ -
    130 };
    │ │ │ │ +
    126 template<std::size_t k>
    │ │ │ │ +
    │ │ │ │ +
    127 void setChild (std::shared_ptr<typename Child<k>::Type> child, index_constant<k> = {})
    │ │ │ │ +
    128 {
    │ │ │ │ +
    129 std::get<k>(_children) = std::move(child);
    │ │ │ │ +
    130 }
    │ │ │ │
    │ │ │ │
    131
    │ │ │ │ -
    133 template<typename F>
    │ │ │ │ -
    │ │ │ │ -
    134 struct lazy_identity
    │ │ │ │ -
    135 {
    │ │ │ │ -
    136 typedef F type;
    │ │ │ │ -
    137 };
    │ │ │ │ +
    │ │ │ │ +
    132 const NodeStorage& nodeStorage () const
    │ │ │ │ +
    133 {
    │ │ │ │ +
    134 return _children;
    │ │ │ │ +
    135 }
    │ │ │ │
    │ │ │ │ +
    136
    │ │ │ │
    138
    │ │ │ │ -
    140 template<typename F>
    │ │ │ │ -
    │ │ │ │ -
    141 struct evaluate_if_meta_function
    │ │ │ │ -
    142 {
    │ │ │ │ -
    143 typedef typename std::conditional<
    │ │ │ │ -
    144 std::is_base_of<meta_function,F>::value,
    │ │ │ │ -
    145 lazy_evaluate<F>,
    │ │ │ │ -
    146 lazy_identity<F>
    │ │ │ │ -
    147 >::type::type type;
    │ │ │ │ -
    148 };
    │ │ │ │ -
    │ │ │ │ -
    149
    │ │ │ │ -
    │ │ │ │ -
    150 namespace impl {
    │ │ │ │ -
    151
    │ │ │ │ -
    152 // Check if type is a or is derived from one of the tree path types
    │ │ │ │ -
    153
    │ │ │ │ -
    154 // Default overload for types not representing a tree path
    │ │ │ │ -
    │ │ │ │ -
    155 constexpr auto isTreePath(void*)
    │ │ │ │ -
    156 -> std::false_type
    │ │ │ │ -
    157 {
    │ │ │ │ -
    158 return std::false_type();
    │ │ │ │ -
    159 }
    │ │ │ │ -
    │ │ │ │ +
    141
    │ │ │ │ +
    142 // The following two methods require a little bit of SFINAE trickery to work correctly:
    │ │ │ │ +
    143 // We have to make sure that they don't shadow the methods for direct child access because
    │ │ │ │ +
    144 // those get called by the generic child() machinery. If that machinery picks up the methods
    │ │ │ │ +
    145 // defined below, we have an infinite recursion.
    │ │ │ │ +
    146 // So the methods make sure that either
    │ │ │ │ +
    147 //
    │ │ │ │ +
    148 // * there are more than one argument. In that case, we got multiple indices and can forward
    │ │ │ │ +
    149 // to the general machine.
    │ │ │ │ +
    150 //
    │ │ │ │ +
    151 // * the first argument is not a valid flat index, i.e. either a std::size_t or an index_constant.
    │ │ │ │ +
    152 // The argument thus has to be some kind of TreePath instance that we can also pass to the
    │ │ │ │ +
    153 // generic machine.
    │ │ │ │ +
    154 //
    │ │ │ │ +
    155 // The above SFINAE logic works, but there is still a problem with the return type deduction.
    │ │ │ │ +
    156 // We have to do a lazy lookup of the return type after SFINAE has succeeded, otherwise the return
    │ │ │ │ +
    157 // type deduction will trigger the infinite recursion.
    │ │ │ │ +
    158
    │ │ │ │
    160
    │ │ │ │ -
    161 // Overload for instances of HybridTreePath<...>
    │ │ │ │ -
    162 template<class... I>
    │ │ │ │ -
    │ │ │ │ -
    163 constexpr auto isTreePath(const HybridTreePath<I...>*)
    │ │ │ │ -
    164 -> std::true_type
    │ │ │ │ -
    165 {
    │ │ │ │ -
    166 return std::true_type();
    │ │ │ │ -
    167 }
    │ │ │ │ -
    │ │ │ │ -
    168
    │ │ │ │ -
    169 }
    │ │ │ │ -
    │ │ │ │ -
    170
    │ │ │ │ -
    181 template<class T>
    │ │ │ │ -
    │ │ │ │ -
    182 struct IsTreePath :
    │ │ │ │ -
    183 public decltype(impl::isTreePath((typename std::decay<T>::type*)(nullptr)))
    │ │ │ │ -
    184 {};
    │ │ │ │ -
    │ │ │ │ -
    185
    │ │ │ │ -
    192 template<class T>
    │ │ │ │ -
    │ │ │ │ -
    193 constexpr auto isTreePath(const T&)
    │ │ │ │ -
    194 -> IsTreePath<T>
    │ │ │ │ -
    195 {
    │ │ │ │ -
    196 return IsTreePath<T>();
    │ │ │ │ -
    197 }
    │ │ │ │ +
    164#ifdef DOXYGEN
    │ │ │ │ +
    165 template<typename... Indices>
    │ │ │ │ +
    │ │ │ │ +
    166 ImplementationDefined& child (Indices... indices)
    │ │ │ │ +
    167#else
    │ │ │ │ +
    168 template<typename I0, typename... I,
    │ │ │ │ +
    169 std::enable_if_t<(sizeof...(I) > 0) || IsTreePath<I0>::value, int > = 0>
    │ │ │ │ +
    170 decltype(auto) child (I0 i0, I... i)
    │ │ │ │ +
    171#endif
    │ │ │ │ +
    172 {
    │ │ │ │ +
    173 static_assert(sizeof...(I) > 0 || impl::_non_empty_tree_path(I0{}),
    │ │ │ │ +
    174 "You cannot use the member function child() with an empty TreePath, use the freestanding version child(node,treePath) instead."
    │ │ │ │ +
    175 );
    │ │ │ │ +
    176 return Dune::TypeTree::child(*this,i0,i...);
    │ │ │ │ +
    177 }
    │ │ │ │ +
    │ │ │ │ +
    178
    │ │ │ │ +
    180
    │ │ │ │ +
    184#ifdef DOXYGEN
    │ │ │ │ +
    185 template<typename... Indices>
    │ │ │ │ +
    │ │ │ │ +
    186 const ImplementationDefined& child (Indices... indices)
    │ │ │ │ +
    187#else
    │ │ │ │ +
    188 template<typename I0, typename... I,
    │ │ │ │ +
    189 std::enable_if_t<(sizeof...(I) > 0) || IsTreePath<I0>::value, int > = 0>
    │ │ │ │ +
    190 decltype(auto) child (I0 i0, I... i) const
    │ │ │ │ +
    191#endif
    │ │ │ │ +
    192 {
    │ │ │ │ +
    193 static_assert(sizeof...(I) > 0 || impl::_non_empty_tree_path(I0{}),
    │ │ │ │ +
    194 "You cannot use the member function child() with an empty TreePath, use the freestanding version child(node,treePath) instead."
    │ │ │ │ +
    195 );
    │ │ │ │ +
    196 return Dune::TypeTree::child(*this,i0,i...);
    │ │ │ │ +
    197 }
    │ │ │ │
    │ │ │ │
    198
    │ │ │ │ -
    199
    │ │ │ │ -
    200 } // end namespace TypeTree
    │ │ │ │ -
    201} // end namespace Dune
    │ │ │ │ +
    200
    │ │ │ │ +
    201 protected:
    │ │ │ │
    202
    │ │ │ │ -
    203#endif // DUNE_TYPETREE_TYPETRAITS_HH
    │ │ │ │ - │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::NodeTag
    typename std::decay_t< Node >::NodeTag NodeTag
    Returns the node tag of the given Node.
    Definition nodeinterface.hh:70
    │ │ │ │ -
    Dune::TypeTree::ImplementationTag
    typename std::decay_t< T >::ImplementationTag ImplementationTag
    Returns the implementation tag of the given Node.
    Definition nodeinterface.hh:74
    │ │ │ │ +
    205
    │ │ │ │ +
    207
    │ │ │ │ +
    │ │ │ │ +
    214 CompositeNode ()
    │ │ │ │ +
    215 {}
    │ │ │ │ +
    │ │ │ │ +
    216
    │ │ │ │ +
    218 template<typename... Args, typename = typename std::enable_if<(sizeof...(Args) == degree())>::type>
    │ │ │ │ +
    │ │ │ │ +
    219 CompositeNode (Args&&... args)
    │ │ │ │ +
    220 : _children(convert_arg(std::forward<Args>(args))...)
    │ │ │ │ +
    221 {}
    │ │ │ │ +
    │ │ │ │ +
    222
    │ │ │ │ +
    │ │ │ │ +
    224 CompositeNode (std::shared_ptr<Children>... children)
    │ │ │ │ +
    225 : _children(std::move(children)...)
    │ │ │ │ +
    226 {}
    │ │ │ │ +
    │ │ │ │ +
    227
    │ │ │ │ +
    │ │ │ │ +
    229 CompositeNode (const NodeStorage& children)
    │ │ │ │ +
    230 : _children(children)
    │ │ │ │ +
    231 {}
    │ │ │ │ +
    │ │ │ │ +
    232
    │ │ │ │ +
    234
    │ │ │ │ +
    235 private:
    │ │ │ │ +
    236 NodeStorage _children;
    │ │ │ │ +
    237 };
    │ │ │ │ +
    │ │ │ │ +
    238
    │ │ │ │ +
    240
    │ │ │ │ +
    241 } // namespace TypeTree
    │ │ │ │ +
    242} //namespace Dune
    │ │ │ │ +
    243
    │ │ │ │ +
    244#endif // DUNE_TYPETREE_COMPOSITENODE_HH
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::child
    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
    │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::isTreePath
    constexpr auto isTreePath(const T &) -> IsTreePath< T >
    Check if given object represents a tree path.
    Definition typetraits.hh:193
    │ │ │ │ -
    Dune::TypeTree::declptr
    T * declptr()
    Helper function for generating a pointer to a value of type T in an unevaluated operand setting.
    │ │ │ │ -
    Dune::TypeTree::impl::isTreePath
    constexpr auto isTreePath(void *) -> std::false_type
    Definition typetraits.hh:155
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath
    A hybrid version of TreePath that supports both compile time and run time indices.
    Definition treepath.hh:158
    │ │ │ │ -
    Dune::first_type
    Definition typetraits.hh:21
    │ │ │ │ -
    Dune::first_type< T0, T... >::type
    T0 type
    Definition typetraits.hh:26
    │ │ │ │ -
    Dune::TypeTree::has_node_tag
    Definition typetraits.hh:33
    │ │ │ │ -
    Dune::TypeTree::has_node_tag::value
    static constexpr bool value
    True if class T defines a NodeTag.
    Definition typetraits.hh:43
    │ │ │ │ -
    Dune::TypeTree::has_node_tag::test
    static yes test(NodeTag< X > *)
    │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::has_node_tag::yes
    Definition typetraits.hh:34
    │ │ │ │ -
    Dune::TypeTree::has_node_tag::yes::dummy
    char dummy[1]
    Definition typetraits.hh:34
    │ │ │ │ -
    Dune::TypeTree::has_node_tag::no
    Definition typetraits.hh:35
    │ │ │ │ -
    Dune::TypeTree::has_node_tag::no::dummy
    char dummy[2]
    Definition typetraits.hh:35
    │ │ │ │ -
    Dune::TypeTree::has_node_tag_value
    Definition typetraits.hh:48
    │ │ │ │ -
    Dune::TypeTree::has_node_tag_value::test
    static maybe< std::is_base_of< V, NodeTag< X > >::value > test(NodeTag< X > *a)
    │ │ │ │ -
    Dune::TypeTree::has_node_tag_value::value
    static constexpr bool value
    True if class T defines a NodeTag of type V.
    Definition typetraits.hh:61
    │ │ │ │ - │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::has_node_tag_value::maybe::dummy
    char dummy[N+1]
    Definition typetraits.hh:50
    │ │ │ │ -
    Dune::TypeTree::has_node_tag_value::yes
    Definition typetraits.hh:51
    │ │ │ │ -
    Dune::TypeTree::has_node_tag_value::yes::dummy
    char dummy[2]
    Definition typetraits.hh:51
    │ │ │ │ -
    Dune::TypeTree::has_node_tag_value::no
    Definition typetraits.hh:52
    │ │ │ │ -
    Dune::TypeTree::has_node_tag_value::no::dummy
    char dummy[1]
    Definition typetraits.hh:52
    │ │ │ │ -
    Dune::TypeTree::has_implementation_tag
    Definition typetraits.hh:66
    │ │ │ │ -
    Dune::TypeTree::has_implementation_tag::test
    static yes test(ImplementationTag< X > *)
    │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::has_implementation_tag::value
    static constexpr bool value
    True if class T defines an ImplementationTag.
    Definition typetraits.hh:76
    │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::has_implementation_tag::yes::dummy
    char dummy[1]
    Definition typetraits.hh:67
    │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::has_implementation_tag::no::dummy
    char dummy[2]
    Definition typetraits.hh:68
    │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::has_implementation_tag_value::test
    static maybe< std::is_base_of< V, ImplementationTag< X > >::value > test(ImplementationTag< X > *a)
    │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::has_implementation_tag_value::value
    static constexpr bool value
    True if class T defines an ImplementationTag of type V.
    Definition typetraits.hh:94
    │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::has_implementation_tag_value::maybe::dummy
    char dummy[N+1]
    Definition typetraits.hh:83
    │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::has_implementation_tag_value::yes::dummy
    char dummy[2]
    Definition typetraits.hh:84
    │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::has_implementation_tag_value::no::dummy
    char dummy[1]
    Definition typetraits.hh:85
    │ │ │ │ -
    Dune::TypeTree::AlwaysVoid
    Definition typetraits.hh:99
    │ │ │ │ -
    Dune::TypeTree::AlwaysVoid::type
    void type
    Definition typetraits.hh:100
    │ │ │ │ -
    Dune::TypeTree::meta_function
    Marker tag declaring a meta function.
    Definition typetraits.hh:123
    │ │ │ │ -
    Dune::TypeTree::lazy_evaluate
    Helper meta function to delay evaluation of F.
    Definition typetraits.hh:128
    │ │ │ │ -
    Dune::TypeTree::lazy_evaluate::type
    F::type type
    Definition typetraits.hh:129
    │ │ │ │ -
    Dune::TypeTree::lazy_identity
    Identity function.
    Definition typetraits.hh:135
    │ │ │ │ -
    Dune::TypeTree::lazy_identity::type
    F type
    Definition typetraits.hh:136
    │ │ │ │ -
    Dune::TypeTree::evaluate_if_meta_function
    Meta function that evaluates its argument iff it inherits from meta_function.
    Definition typetraits.hh:142
    │ │ │ │ -
    Dune::TypeTree::evaluate_if_meta_function::type
    std::conditional< std::is_base_of< meta_function, F >::value, lazy_evaluate< F >, lazy_identity< F > >::type::type type
    Definition typetraits.hh:147
    │ │ │ │ +
    Dune::TypeTree::CompositeNode
    Base class for composite nodes based on variadic templates.
    Definition compositenode.hh:28
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::isLeaf
    static const bool isLeaf
    Mark this class as non leaf in the dune-typetree.
    Definition compositenode.hh:42
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::child
    ImplementationDefined & child(Indices... indices)
    Returns the child given by the list of indices.
    Definition compositenode.hh:166
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::isComposite
    static const bool isComposite
    Mark this class as a composite in the dune-typetree.
    Definition compositenode.hh:48
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::CompositeNode
    CompositeNode()
    Default constructor.
    Definition compositenode.hh:214
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::NodeTag
    CompositeNodeTag NodeTag
    The type tag that describes a CompositeNode.
    Definition compositenode.hh:33
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::setChild
    void setChild(typename Child< k >::Type &child, index_constant< k >={})
    Sets the k-th child to the passed-in value.
    Definition compositenode.hh:113
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::setChild
    void setChild(typename Child< k >::Type &&child, index_constant< k >={})
    Store the passed value in k-th child.
    Definition compositenode.hh:120
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::degree
    static constexpr auto degree()
    Definition compositenode.hh:50
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::nodeStorage
    const NodeStorage & nodeStorage() const
    Definition compositenode.hh:132
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::CompositeNode
    CompositeNode(std::shared_ptr< Children >... children)
    Initialize the CompositeNode with copies of the passed in Storage objects.
    Definition compositenode.hh:224
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::childStorage
    std::shared_ptr< typename Child< k >::Type > childStorage(index_constant< k >={})
    Returns the storage of the k-th child.
    Definition compositenode.hh:96
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::ChildTypes
    std::tuple< Children... > ChildTypes
    A tuple storing the types of all children.
    Definition compositenode.hh:39
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::setChild
    void setChild(std::shared_ptr< typename Child< k >::Type > child, index_constant< k >={})
    Sets the storage of the k-th child to the passed-in value.
    Definition compositenode.hh:127
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::child
    const ImplementationDefined & child(Indices... indices)
    Returns the child given by the list of indices.
    Definition compositenode.hh:186
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::isPower
    static const bool isPower
    Mark this class as a non power in the dune-typetree.
    Definition compositenode.hh:45
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::childStorage
    std::shared_ptr< const typename Child< k >::Type > childStorage(index_constant< k >={}) const
    Returns the storage of the k-th child (const version).
    Definition compositenode.hh:106
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::child
    Child< k >::Type & child(index_constant< k >={})
    Returns the k-th child.
    Definition compositenode.hh:76
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::CompositeNode
    CompositeNode(const NodeStorage &children)
    Initialize the CompositeNode with a copy of the passed-in storage type.
    Definition compositenode.hh:229
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::NodeStorage
    std::tuple< std::shared_ptr< Children >... > NodeStorage
    The type used for storing the children.
    Definition compositenode.hh:36
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::child
    const Child< k >::Type & child(index_constant< k >={}) const
    Returns the k-th child (const version).
    Definition compositenode.hh:86
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::Child
    Access to the type and storage type of the i-th child.
    Definition compositenode.hh:57
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::Child::Type
    std::tuple_element< k, ChildTypes >::type Type
    The type of the child.
    Definition compositenode.hh:62
    │ │ │ │ +
    Dune::TypeTree::CompositeNode::Child::type
    std::tuple_element< k, ChildTypes >::type type
    The type of the child.
    Definition compositenode.hh:65
    │ │ │ │ +
    Dune::TypeTree::CompositeNodeTag
    Tag designating a composite node.
    Definition nodetags.hh:27
    │ │ │ │
    Dune::TypeTree::IsTreePath
    Check if type represents a tree path.
    Definition typetraits.hh:184
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,346 +1,323 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -typetraits.hh │ │ │ │ │ +compositenode.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_TYPETRAITS_HH │ │ │ │ │ -7#define DUNE_TYPETREE_TYPETRAITS_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_COMPOSITENODE_HH │ │ │ │ │ +7#define DUNE_TYPETREE_COMPOSITENODE_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include │ │ │ │ │ -10#include │ │ │ │ │ -11 │ │ │ │ │ -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_/_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h> │ │ │ │ │ -14 │ │ │ │ │ -15namespace _D_u_n_e { │ │ │ │ │ +9#include │ │ │ │ │ +10#include │ │ │ │ │ +11#include │ │ │ │ │ +12 │ │ │ │ │ +13#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ +14#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h> │ │ │ │ │ +15#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_y_p_e_t_r_a_i_t_s_._h_h> │ │ │ │ │ 16 │ │ │ │ │ -17 // Provide some more C++11 TMP helpers. │ │ │ │ │ -18 // These should be upstreamed to dune-common ASAP. │ │ │ │ │ +17namespace _D_u_n_e { │ │ │ │ │ +18 namespace TypeTree { │ │ │ │ │ 19 │ │ │ │ │ -20 template │ │ │ │ │ -_2_1 struct _f_i_r_s_t___t_y_p_e; │ │ │ │ │ -22 │ │ │ │ │ -23 template │ │ │ │ │ -_2_4 struct _f_i_r_s_t___t_y_p_e │ │ │ │ │ -25 { │ │ │ │ │ -_2_6 typedef T0 _t_y_p_e; │ │ │ │ │ -27 }; │ │ │ │ │ -28 │ │ │ │ │ -29 namespace TypeTree { │ │ │ │ │ -30 │ │ │ │ │ -31 template │ │ │ │ │ -_3_2 struct _h_a_s___n_o_d_e___t_a_g │ │ │ │ │ -33 { │ │ │ │ │ -_3_4 struct _y_e_s { char _d_u_m_m_y[1]; }; │ │ │ │ │ -_3_5 struct _n_o { char _d_u_m_m_y[2]; }; │ │ │ │ │ -36 │ │ │ │ │ -37 template │ │ │ │ │ -_3_8 static _y_e_s _t_e_s_t(_N_o_d_e_T_a_g_<_X_> *); │ │ │ │ │ -39 template │ │ │ │ │ -_4_0 static _n_o _t_e_s_t(...); │ │ │ │ │ -41 │ │ │ │ │ -_4_3 constexpr static bool _v_a_l_u_e = sizeof(test(0)) == sizeof(_y_e_s); │ │ │ │ │ -44 }; │ │ │ │ │ -45 │ │ │ │ │ -46 template │ │ │ │ │ -_4_7 struct _h_a_s___n_o_d_e___t_a_g___v_a_l_u_e │ │ │ │ │ -48 { │ │ │ │ │ -49 template │ │ │ │ │ -_5_0 struct _m_a_y_b_e { char _d_u_m_m_y[N+1]; }; │ │ │ │ │ -_5_1 struct _y_e_s { char _d_u_m_m_y[2]; }; │ │ │ │ │ -_5_2 struct _n_o { char _d_u_m_m_y[1]; }; │ │ │ │ │ -53 │ │ │ │ │ -54 template │ │ │ │ │ -55 static _m_a_y_b_e_<_s_t_d_:_:_i_s___b_a_s_e___o_f_<_V_,_ _N_o_d_e_T_a_g_<_X_>>_:_:_v_a_l_u_e> │ │ │ │ │ -_5_6 _t_e_s_t(_N_o_d_e_T_a_g_<_X_> * a); │ │ │ │ │ -57 template │ │ │ │ │ -_5_8 static _n_o _t_e_s_t(...); │ │ │ │ │ -59 │ │ │ │ │ -_6_1 constexpr static bool _v_a_l_u_e = sizeof(test(0)) == sizeof(_y_e_s); │ │ │ │ │ -62 }; │ │ │ │ │ +26 template │ │ │ │ │ +_2_7 class _C_o_m_p_o_s_i_t_e_N_o_d_e │ │ │ │ │ +28 { │ │ │ │ │ +29 │ │ │ │ │ +30 public: │ │ │ │ │ +31 │ │ │ │ │ +_3_3 typedef _C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g _N_o_d_e_T_a_g; │ │ │ │ │ +34 │ │ │ │ │ +_3_6 typedef std::tuple... > _N_o_d_e_S_t_o_r_a_g_e; │ │ │ │ │ +37 │ │ │ │ │ +_3_9 typedef std::tuple _C_h_i_l_d_T_y_p_e_s; │ │ │ │ │ +40 │ │ │ │ │ +_4_2 static const bool _i_s_L_e_a_f = false; │ │ │ │ │ +43 │ │ │ │ │ +_4_5 static const bool _i_s_P_o_w_e_r = false; │ │ │ │ │ +46 │ │ │ │ │ +_4_8 static const bool _i_s_C_o_m_p_o_s_i_t_e = true; │ │ │ │ │ +49 │ │ │ │ │ +_5_0 static constexpr auto _d_e_g_r_e_e () │ │ │ │ │ +51 { │ │ │ │ │ +52 return std::integral_constant{}; │ │ │ │ │ +53 } │ │ │ │ │ +54 │ │ │ │ │ +56 template │ │ │ │ │ +_5_7 struct _C_h_i_l_d { │ │ │ │ │ +58 │ │ │ │ │ +59 static_assert((k < _d_e_g_r_e_e()), "child index out of range"); │ │ │ │ │ +60 │ │ │ │ │ +_6_2 typedef typename std::tuple_element::type _T_y_p_e; │ │ │ │ │ 63 │ │ │ │ │ -64 template │ │ │ │ │ -_6_5 struct _h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g │ │ │ │ │ -66 { │ │ │ │ │ -_6_7 struct _y_e_s { char _d_u_m_m_y[1]; }; │ │ │ │ │ -_6_8 struct _n_o { char _d_u_m_m_y[2]; }; │ │ │ │ │ -69 │ │ │ │ │ -70 template │ │ │ │ │ -_7_1 static _y_e_s _t_e_s_t(_I_m_p_l_e_m_e_n_t_a_t_i_o_n_T_a_g_<_X_> *); │ │ │ │ │ -72 template │ │ │ │ │ -_7_3 static _n_o _t_e_s_t(...); │ │ │ │ │ -74 │ │ │ │ │ -_7_6 constexpr static bool _v_a_l_u_e = sizeof(test(0)) == sizeof(_y_e_s); │ │ │ │ │ -77 }; │ │ │ │ │ -78 │ │ │ │ │ -79 template │ │ │ │ │ -_8_0 struct _h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e │ │ │ │ │ -81 { │ │ │ │ │ -82 template │ │ │ │ │ -_8_3 struct _m_a_y_b_e { char _d_u_m_m_y[N+1]; }; │ │ │ │ │ -_8_4 struct _y_e_s { char _d_u_m_m_y[2]; }; │ │ │ │ │ -_8_5 struct _n_o { char _d_u_m_m_y[1]; }; │ │ │ │ │ -86 │ │ │ │ │ -87 template │ │ │ │ │ -88 static _m_a_y_b_e_<_s_t_d_:_:_i_s___b_a_s_e___o_f_<_V_,_ _I_m_p_l_e_m_e_n_t_a_t_i_o_n_T_a_g_<_X_>>_:_:_v_a_l_u_e> │ │ │ │ │ -_8_9 _t_e_s_t(_I_m_p_l_e_m_e_n_t_a_t_i_o_n_T_a_g_<_X_> * a); │ │ │ │ │ -90 template │ │ │ │ │ -_9_1 static _n_o _t_e_s_t(...); │ │ │ │ │ +_6_5 typedef typename std::tuple_element::type _t_y_p_e; │ │ │ │ │ +66 }; │ │ │ │ │ +67 │ │ │ │ │ +70 │ │ │ │ │ +72 │ │ │ │ │ +75 template │ │ │ │ │ +_7_6 typename _C_h_i_l_d_<_k_>_:_:_T_y_p_e& _c_h_i_l_d (index_constant = {}) │ │ │ │ │ +77 { │ │ │ │ │ +78 return *std::get(_children); │ │ │ │ │ +79 } │ │ │ │ │ +80 │ │ │ │ │ +82 │ │ │ │ │ +85 template │ │ │ │ │ +_8_6 const typename _C_h_i_l_d_<_k_>_:_:_T_y_p_e& _c_h_i_l_d (index_constant = {}) const │ │ │ │ │ +87 { │ │ │ │ │ +88 return *std::get(_children); │ │ │ │ │ +89 } │ │ │ │ │ +90 │ │ │ │ │ 92 │ │ │ │ │ -_9_4 constexpr static bool _v_a_l_u_e = sizeof(test(0)) == sizeof(_y_e_s); │ │ │ │ │ -95 }; │ │ │ │ │ -96 │ │ │ │ │ -97 template │ │ │ │ │ -_9_8 struct _A_l_w_a_y_s_V_o_i_d │ │ │ │ │ -99 { │ │ │ │ │ -_1_0_0 typedef void _t_y_p_e; │ │ │ │ │ -101 }; │ │ │ │ │ +95 template │ │ │ │ │ +_9_6 std::shared_ptr::Type> _c_h_i_l_d_S_t_o_r_a_g_e (index_constant = │ │ │ │ │ +{}) │ │ │ │ │ +97 { │ │ │ │ │ +98 return std::get(_children); │ │ │ │ │ +99 } │ │ │ │ │ +100 │ │ │ │ │ 102 │ │ │ │ │ -103 │ │ │ │ │ -105 template │ │ │ │ │ -_1_0_6 T* _d_e_c_l_p_t_r(); │ │ │ │ │ -107 │ │ │ │ │ -108 │ │ │ │ │ -109 // Support for lazy evaluation of meta functions. This is required when │ │ │ │ │ -doing │ │ │ │ │ -110 // nested tag dispatch without C++11-style typedefs (based on using │ │ │ │ │ -syntax). │ │ │ │ │ -111 // The standard struct-based meta functions cause premature evaluation in a │ │ │ │ │ -112 // context that is not SFINAE-compatible. We thus have to return the meta │ │ │ │ │ -function │ │ │ │ │ -113 // without evaluating it, placing that burden on the caller. On the other │ │ │ │ │ -hand, │ │ │ │ │ -114 // the lookup will often directly be the target type, so here is some │ │ │ │ │ -helper code │ │ │ │ │ -115 // to automatically do the additional evaluation if necessary. │ │ │ │ │ -116 // Too bad that the new syntax is GCC 4.6+... │ │ │ │ │ +105 template │ │ │ │ │ +_1_0_6 std::shared_ptr::Type> _c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ +(index_constant = {}) const │ │ │ │ │ +107 { │ │ │ │ │ +108 return std::get(_children); │ │ │ │ │ +109 } │ │ │ │ │ +110 │ │ │ │ │ +112 template │ │ │ │ │ +_1_1_3 void _s_e_t_C_h_i_l_d (typename _C_h_i_l_d_<_k_>_:_:_T_y_p_e& _c_h_i_l_d, index_constant = {}) │ │ │ │ │ +114 { │ │ │ │ │ +115 std::get(_children) = stackobject_to_shared_ptr(_c_h_i_l_d); │ │ │ │ │ +116 } │ │ │ │ │ 117 │ │ │ │ │ -118 │ │ │ │ │ -120 │ │ │ │ │ -_1_2_3 struct _m_e_t_a___f_u_n_c_t_i_o_n {}; │ │ │ │ │ +119 template │ │ │ │ │ +_1_2_0 void _s_e_t_C_h_i_l_d (typename _C_h_i_l_d_<_k_>_:_:_T_y_p_e&& _c_h_i_l_d, index_constant = {}) │ │ │ │ │ +121 { │ │ │ │ │ +122 std::get(_children) = convert_arg(std::move(_c_h_i_l_d)); │ │ │ │ │ +123 } │ │ │ │ │ 124 │ │ │ │ │ -126 template │ │ │ │ │ -_1_2_7 struct _l_a_z_y___e_v_a_l_u_a_t_e │ │ │ │ │ +126 template │ │ │ │ │ +_1_2_7 void _s_e_t_C_h_i_l_d (std::shared_ptr_:_:_T_y_p_e> _c_h_i_l_d, │ │ │ │ │ +index_constant = {}) │ │ │ │ │ 128 { │ │ │ │ │ -_1_2_9 typedef typename F::type _t_y_p_e; │ │ │ │ │ -130 }; │ │ │ │ │ +129 std::get(_children) = std::move(_c_h_i_l_d); │ │ │ │ │ +130 } │ │ │ │ │ 131 │ │ │ │ │ -133 template │ │ │ │ │ -_1_3_4 struct _l_a_z_y___i_d_e_n_t_i_t_y │ │ │ │ │ -135 { │ │ │ │ │ -_1_3_6 typedef F _t_y_p_e; │ │ │ │ │ -137 }; │ │ │ │ │ +_1_3_2 const _N_o_d_e_S_t_o_r_a_g_e& _n_o_d_e_S_t_o_r_a_g_e () const │ │ │ │ │ +133 { │ │ │ │ │ +134 return _children; │ │ │ │ │ +135 } │ │ │ │ │ +136 │ │ │ │ │ 138 │ │ │ │ │ -140 template │ │ │ │ │ -_1_4_1 struct _e_v_a_l_u_a_t_e___i_f___m_e_t_a___f_u_n_c_t_i_o_n │ │ │ │ │ -142 { │ │ │ │ │ -143 typedef typename std::conditional< │ │ │ │ │ -144 std::is_base_of::value, │ │ │ │ │ -145 _l_a_z_y___e_v_a_l_u_a_t_e_<_F_>, │ │ │ │ │ -146 _l_a_z_y___i_d_e_n_t_i_t_y_<_F_> │ │ │ │ │ -_1_4_7 >::type::type _t_y_p_e; │ │ │ │ │ -148 }; │ │ │ │ │ -149 │ │ │ │ │ -_1_5_0 namespace impl { │ │ │ │ │ -151 │ │ │ │ │ -152 // Check if type is a or is derived from one of the tree path types │ │ │ │ │ -153 │ │ │ │ │ -154 // Default overload for types not representing a tree path │ │ │ │ │ -_1_5_5 constexpr auto _i_s_T_r_e_e_P_a_t_h(void*) │ │ │ │ │ -156 -> std::false_type │ │ │ │ │ -157 { │ │ │ │ │ -158 return std::false_type(); │ │ │ │ │ -159 } │ │ │ │ │ +141 │ │ │ │ │ +142 // The following two methods require a little bit of SFINAE trickery to │ │ │ │ │ +work correctly: │ │ │ │ │ +143 // We have to make sure that they don't shadow the methods for direct child │ │ │ │ │ +access because │ │ │ │ │ +144 // those get called by the generic child() machinery. If that machinery │ │ │ │ │ +picks up the methods │ │ │ │ │ +145 // defined below, we have an infinite recursion. │ │ │ │ │ +146 // So the methods make sure that either │ │ │ │ │ +147 // │ │ │ │ │ +148 // * there are more than one argument. In that case, we got multiple │ │ │ │ │ +indices and can forward │ │ │ │ │ +149 // to the general machine. │ │ │ │ │ +150 // │ │ │ │ │ +151 // * the first argument is not a valid flat index, i.e. either a std:: │ │ │ │ │ +size_t or an index_constant. │ │ │ │ │ +152 // The argument thus has to be some kind of TreePath instance that we can │ │ │ │ │ +also pass to the │ │ │ │ │ +153 // generic machine. │ │ │ │ │ +154 // │ │ │ │ │ +155 // The above SFINAE logic works, but there is still a problem with the │ │ │ │ │ +return type deduction. │ │ │ │ │ +156 // We have to do a lazy lookup of the return type after SFINAE has │ │ │ │ │ +succeeded, otherwise the return │ │ │ │ │ +157 // type deduction will trigger the infinite recursion. │ │ │ │ │ +158 │ │ │ │ │ 160 │ │ │ │ │ -161 // Overload for instances of HybridTreePath<...> │ │ │ │ │ -162 template │ │ │ │ │ -_1_6_3 constexpr auto _i_s_T_r_e_e_P_a_t_h(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_I_._._._>*) │ │ │ │ │ -164 -> std::true_type │ │ │ │ │ -165 { │ │ │ │ │ -166 return std::true_type(); │ │ │ │ │ -167 } │ │ │ │ │ -168 │ │ │ │ │ -169 } │ │ │ │ │ -170 │ │ │ │ │ -181 template │ │ │ │ │ -_1_8_2 struct _I_s_T_r_e_e_P_a_t_h : │ │ │ │ │ -183 public decltype(impl::isTreePath((typename std::decay::type*)(nullptr))) │ │ │ │ │ -184 {}; │ │ │ │ │ -185 │ │ │ │ │ -192 template │ │ │ │ │ -_1_9_3 constexpr auto _i_s_T_r_e_e_P_a_t_h(const T&) │ │ │ │ │ -194 -> _I_s_T_r_e_e_P_a_t_h_<_T_> │ │ │ │ │ -195 { │ │ │ │ │ -196 return _I_s_T_r_e_e_P_a_t_h_<_T_>(); │ │ │ │ │ +164#ifdef DOXYGEN │ │ │ │ │ +165 template │ │ │ │ │ +_1_6_6 ImplementationDefined& _c_h_i_l_d (Indices... indices) │ │ │ │ │ +167#else │ │ │ │ │ +168 template 0) || _I_s_T_r_e_e_P_a_t_h_<_I_0_>_:_:_v_a_l_u_e, int > = 0> │ │ │ │ │ +170 decltype(auto) _c_h_i_l_d (I0 i0, I... i) │ │ │ │ │ +171#endif │ │ │ │ │ +172 { │ │ │ │ │ +173 static_assert(sizeof...(I) > 0 || impl::_non_empty_tree_path(I0{}), │ │ │ │ │ +174 "You cannot use the member function child() with an empty TreePath, use the │ │ │ │ │ +freestanding version child(node,treePath) instead." │ │ │ │ │ +175 ); │ │ │ │ │ +176 return _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_c_h_i_l_d(*this,i0,i...); │ │ │ │ │ +177 } │ │ │ │ │ +178 │ │ │ │ │ +180 │ │ │ │ │ +184#ifdef DOXYGEN │ │ │ │ │ +185 template │ │ │ │ │ +_1_8_6 const ImplementationDefined& _c_h_i_l_d (Indices... indices) │ │ │ │ │ +187#else │ │ │ │ │ +188 template 0) || _I_s_T_r_e_e_P_a_t_h_<_I_0_>_:_:_v_a_l_u_e, int > = 0> │ │ │ │ │ +190 decltype(auto) _c_h_i_l_d (I0 i0, I... i) const │ │ │ │ │ +191#endif │ │ │ │ │ +192 { │ │ │ │ │ +193 static_assert(sizeof...(I) > 0 || impl::_non_empty_tree_path(I0{}), │ │ │ │ │ +194 "You cannot use the member function child() with an empty TreePath, use the │ │ │ │ │ +freestanding version child(node,treePath) instead." │ │ │ │ │ +195 ); │ │ │ │ │ +196 return _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_c_h_i_l_d(*this,i0,i...); │ │ │ │ │ 197 } │ │ │ │ │ 198 │ │ │ │ │ -199 │ │ │ │ │ -200 } // end namespace TypeTree │ │ │ │ │ -201} // end namespace Dune │ │ │ │ │ +200 │ │ │ │ │ +201 protected: │ │ │ │ │ 202 │ │ │ │ │ -203#endif // DUNE_TYPETREE_TYPETRAITS_HH │ │ │ │ │ -_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h │ │ │ │ │ -_t_r_e_e_p_a_t_h_._h_h │ │ │ │ │ -_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_:_:_I_m_p_l_e_m_e_n_t_a_t_i_o_n_T_a_g │ │ │ │ │ -typename std::decay_t< T >::ImplementationTag ImplementationTag │ │ │ │ │ -Returns the implementation tag of the given Node. │ │ │ │ │ -DDeeffiinniittiioonn nodeinterface.hh:74 │ │ │ │ │ +205 │ │ │ │ │ +207 │ │ │ │ │ +_2_1_4 _C_o_m_p_o_s_i_t_e_N_o_d_e () │ │ │ │ │ +215 {} │ │ │ │ │ +216 │ │ │ │ │ +218 template::type> │ │ │ │ │ +_2_1_9 _C_o_m_p_o_s_i_t_e_N_o_d_e (Args&&... args) │ │ │ │ │ +220 : _children(convert_arg(std::forward(args))...) │ │ │ │ │ +221 {} │ │ │ │ │ +222 │ │ │ │ │ +_2_2_4 _C_o_m_p_o_s_i_t_e_N_o_d_e (std::shared_ptr... children) │ │ │ │ │ +225 : _children(std::move(children)...) │ │ │ │ │ +226 {} │ │ │ │ │ +227 │ │ │ │ │ +_2_2_9 _C_o_m_p_o_s_i_t_e_N_o_d_e (const _N_o_d_e_S_t_o_r_a_g_e& children) │ │ │ │ │ +230 : _children(children) │ │ │ │ │ +231 {} │ │ │ │ │ +232 │ │ │ │ │ +234 │ │ │ │ │ +235 private: │ │ │ │ │ +236 _N_o_d_e_S_t_o_r_a_g_e _children; │ │ │ │ │ +237 }; │ │ │ │ │ +238 │ │ │ │ │ +240 │ │ │ │ │ +241 } // namespace TypeTree │ │ │ │ │ +242} //namespace Dune │ │ │ │ │ +243 │ │ │ │ │ +244#endif // DUNE_TYPETREE_COMPOSITENODE_HH │ │ │ │ │ +_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h │ │ │ │ │ +_t_y_p_e_t_r_a_i_t_s_._h_h │ │ │ │ │ +_n_o_d_e_t_a_g_s_._h_h │ │ │ │ │ +_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 │ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_s_T_r_e_e_P_a_t_h │ │ │ │ │ -constexpr auto isTreePath(const T &) -> IsTreePath< T > │ │ │ │ │ -Check if given object represents a tree path. │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:193 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_d_e_c_l_p_t_r │ │ │ │ │ -T * declptr() │ │ │ │ │ -Helper function for generating a pointer to a value of type T in an unevaluated │ │ │ │ │ -operand setting. │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_m_p_l_:_:_i_s_T_r_e_e_P_a_t_h │ │ │ │ │ -constexpr auto isTreePath(void *) -> std::false_type │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:155 │ │ │ │ │ -_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_:_:_f_i_r_s_t___t_y_p_e │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:21 │ │ │ │ │ -_D_u_n_e_:_:_f_i_r_s_t___t_y_p_e_<_ _T_0_,_ _T_._._._ _>_:_:_t_y_p_e │ │ │ │ │ -T0 type │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:26 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:33 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_:_:_v_a_l_u_e │ │ │ │ │ -static constexpr bool value │ │ │ │ │ -True if class T defines a NodeTag. │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:43 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_:_:_t_e_s_t │ │ │ │ │ -static yes test(NodeTag< X > *) │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_:_:_t_e_s_t │ │ │ │ │ -static no test(...) │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_:_:_y_e_s │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:34 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_:_:_y_e_s_:_:_d_u_m_m_y │ │ │ │ │ -char dummy[1] │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:34 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_:_:_n_o │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:35 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g_:_:_n_o_:_:_d_u_m_m_y │ │ │ │ │ -char dummy[2] │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:35 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:48 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_:_:_t_e_s_t │ │ │ │ │ -static maybe< std::is_base_of< V, NodeTag< X > >::value > test(NodeTag< X > *a) │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_:_:_v_a_l_u_e │ │ │ │ │ -static constexpr bool value │ │ │ │ │ -True if class T defines a NodeTag of type V. │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:61 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_:_:_t_e_s_t │ │ │ │ │ -static no test(...) │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_:_:_m_a_y_b_e │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:50 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_:_:_m_a_y_b_e_:_:_d_u_m_m_y │ │ │ │ │ -char dummy[N+1] │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:50 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_:_:_y_e_s │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:51 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_:_:_y_e_s_:_:_d_u_m_m_y │ │ │ │ │ -char dummy[2] │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:51 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_:_:_n_o │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:52 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___n_o_d_e___t_a_g___v_a_l_u_e_:_:_n_o_:_:_d_u_m_m_y │ │ │ │ │ -char dummy[1] │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:52 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:66 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_:_:_t_e_s_t │ │ │ │ │ -static yes test(ImplementationTag< X > *) │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_:_:_t_e_s_t │ │ │ │ │ -static no test(...) │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_:_:_v_a_l_u_e │ │ │ │ │ -static constexpr bool value │ │ │ │ │ -True if class T defines an ImplementationTag. │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:76 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_:_:_y_e_s │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:67 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_:_:_y_e_s_:_:_d_u_m_m_y │ │ │ │ │ -char dummy[1] │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:67 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_:_:_n_o │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:68 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g_:_:_n_o_:_:_d_u_m_m_y │ │ │ │ │ -char dummy[2] │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:68 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:81 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_:_:_t_e_s_t │ │ │ │ │ -static maybe< std::is_base_of< V, ImplementationTag< X > >::value > test │ │ │ │ │ -(ImplementationTag< X > *a) │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_:_:_t_e_s_t │ │ │ │ │ -static no test(...) │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_:_:_v_a_l_u_e │ │ │ │ │ -static constexpr bool value │ │ │ │ │ -True if class T defines an ImplementationTag of type V. │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:94 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_:_:_m_a_y_b_e │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:83 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_:_:_m_a_y_b_e_:_:_d_u_m_m_y │ │ │ │ │ -char dummy[N+1] │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:83 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_:_:_y_e_s │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:84 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_:_:_y_e_s_:_:_d_u_m_m_y │ │ │ │ │ -char dummy[2] │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:84 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_:_:_n_o │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:85 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_h_a_s___i_m_p_l_e_m_e_n_t_a_t_i_o_n___t_a_g___v_a_l_u_e_:_:_n_o_:_:_d_u_m_m_y │ │ │ │ │ -char dummy[1] │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:85 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_l_w_a_y_s_V_o_i_d │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:99 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_l_w_a_y_s_V_o_i_d_:_:_t_y_p_e │ │ │ │ │ -void type │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:100 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_e_t_a___f_u_n_c_t_i_o_n │ │ │ │ │ -Marker tag declaring a meta function. │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:123 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_l_a_z_y___e_v_a_l_u_a_t_e │ │ │ │ │ -Helper meta function to delay evaluation of F. │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:128 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_l_a_z_y___e_v_a_l_u_a_t_e_:_:_t_y_p_e │ │ │ │ │ -F::type type │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:129 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_l_a_z_y___i_d_e_n_t_i_t_y │ │ │ │ │ -Identity function. │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:135 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_l_a_z_y___i_d_e_n_t_i_t_y_:_:_t_y_p_e │ │ │ │ │ -F type │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:136 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_e_v_a_l_u_a_t_e___i_f___m_e_t_a___f_u_n_c_t_i_o_n │ │ │ │ │ -Meta function that evaluates its argument iff it inherits from meta_function. │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:142 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_e_v_a_l_u_a_t_e___i_f___m_e_t_a___f_u_n_c_t_i_o_n_:_:_t_y_p_e │ │ │ │ │ -std::conditional< std::is_base_of< meta_function, F >::value, lazy_evaluate< F │ │ │ │ │ ->, lazy_identity< F > >::type::type type │ │ │ │ │ -DDeeffiinniittiioonn typetraits.hh:147 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e │ │ │ │ │ +Base class for composite nodes based on variadic templates. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:28 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_i_s_L_e_a_f │ │ │ │ │ +static const bool isLeaf │ │ │ │ │ +Mark this class as non leaf in the dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:42 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ +ImplementationDefined & child(Indices... indices) │ │ │ │ │ +Returns the child given by the list of indices. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:166 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_i_s_C_o_m_p_o_s_i_t_e │ │ │ │ │ +static const bool isComposite │ │ │ │ │ +Mark this class as a composite in the dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:48 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e │ │ │ │ │ +CompositeNode() │ │ │ │ │ +Default constructor. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:214 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_N_o_d_e_T_a_g │ │ │ │ │ +CompositeNodeTag NodeTag │ │ │ │ │ +The type tag that describes a CompositeNode. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:33 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ +void setChild(typename Child< k >::Type &child, index_constant< k >={}) │ │ │ │ │ +Sets the k-th child to the passed-in value. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:113 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ +void setChild(typename Child< k >::Type &&child, index_constant< k >={}) │ │ │ │ │ +Store the passed value in k-th child. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:120 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_d_e_g_r_e_e │ │ │ │ │ +static constexpr auto degree() │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:50 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_n_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ +const NodeStorage & nodeStorage() const │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:132 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e │ │ │ │ │ +CompositeNode(std::shared_ptr< Children >... children) │ │ │ │ │ +Initialize the CompositeNode with copies of the passed in Storage objects. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:224 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ +std::shared_ptr< typename Child< k >::Type > childStorage(index_constant< k >= │ │ │ │ │ +{}) │ │ │ │ │ +Returns the storage of the k-th child. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:96 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_h_i_l_d_T_y_p_e_s │ │ │ │ │ +std::tuple< Children... > ChildTypes │ │ │ │ │ +A tuple storing the types of all children. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:39 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ +void setChild(std::shared_ptr< typename Child< k >::Type > child, │ │ │ │ │ +index_constant< k >={}) │ │ │ │ │ +Sets the storage of the k-th child to the passed-in value. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:127 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ +const ImplementationDefined & child(Indices... indices) │ │ │ │ │ +Returns the child given by the list of indices. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:186 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_i_s_P_o_w_e_r │ │ │ │ │ +static const bool isPower │ │ │ │ │ +Mark this class as a non power in the dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:45 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ +std::shared_ptr< const typename Child< k >::Type > childStorage(index_constant< │ │ │ │ │ +k >={}) const │ │ │ │ │ +Returns the storage of the k-th child (const version). │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:106 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ +Child< k >::Type & child(index_constant< k >={}) │ │ │ │ │ +Returns the k-th child. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:76 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e │ │ │ │ │ +CompositeNode(const NodeStorage &children) │ │ │ │ │ +Initialize the CompositeNode with a copy of the passed-in storage type. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:229 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ +std::tuple< std::shared_ptr< Children >... > NodeStorage │ │ │ │ │ +The type used for storing the children. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:36 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ +const Child< k >::Type & child(index_constant< k >={}) const │ │ │ │ │ +Returns the k-th child (const version). │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:86 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_h_i_l_d │ │ │ │ │ +Access to the type and storage type of the i-th child. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:57 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_h_i_l_d_:_:_T_y_p_e │ │ │ │ │ +std::tuple_element< k, ChildTypes >::type Type │ │ │ │ │ +The type of the child. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:62 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_h_i_l_d_:_:_t_y_p_e │ │ │ │ │ +std::tuple_element< k, ChildTypes >::type type │ │ │ │ │ +The type of the child. │ │ │ │ │ +DDeeffiinniittiioonn compositenode.hh:65 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g │ │ │ │ │ +Tag designating a composite node. │ │ │ │ │ +DDeeffiinniittiioonn nodetags.hh:27 │ │ │ │ │ _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_I_s_T_r_e_e_P_a_t_h │ │ │ │ │ Check if type represents a tree path. │ │ │ │ │ DDeeffiinniittiioonn typetraits.hh:184 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00047.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: utility.hh File Reference │ │ │ │ +dune-typetree: filters.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -72,33 +72,61 @@ │ │ │ │
  • dune
  • typetree
    • │ │ │ │
    │ │ │ │
    │ │ │ │
    │ │ │ │
    │ │ │ │ Classes | │ │ │ │ Namespaces
    │ │ │ │ -
    utility.hh File Reference
    │ │ │ │ +
    filters.hh File Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │ -
    #include <memory>
    │ │ │ │ -#include <tuple>
    │ │ │ │ -#include <type_traits>
    │ │ │ │ -#include <utility>
    │ │ │ │ -#include <algorithm>
    │ │ │ │ -#include <dune/common/shared_ptr.hh>
    │ │ │ │ -#include <dune/common/indices.hh>
    │ │ │ │ -#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ -#include <dune/typetree/nodetags.hh>
    │ │ │ │ +
    #include <tuple>
    │ │ │ │ +#include <dune/common/typetraits.hh>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  Dune::TypeTree::TreeInfo< Tree, Tag >
     Struct for obtaining some basic structural information about a TypeTree. More...
    struct  Dune::TypeTree::FilterEntry< new_k, old_k >
     A filter entry describing the mapping of one child in the filtered node. More...
     
    struct  Dune::TypeTree::FilterResult< FilterEntries >
     The result of a filter. More...
     
    struct  Dune::TypeTree::FilterResult< FilterEntries >::apply< Node >
     
    struct  Dune::TypeTree::SimpleFilterTag
     Tag describing a simple filter that can only decide whether or not to include a single given child. More...
     
    struct  Dune::TypeTree::AdvancedFilterTag
     Tag describing an advanced filter that has full control over the construction of the list of FilterEntries. More...
     
    struct  Dune::TypeTree::AdvancedFilter
     Base class for advanced filters. More...
     
    struct  Dune::TypeTree::AdvancedFilter::apply< Node, Children >
     Apply this filter to the given node and children. More...
     
    struct  Dune::TypeTree::SimpleFilter
     Default simple filter that accepts any node and leaves its child structure unchanged. More...
     
    struct  Dune::TypeTree::SimpleFilter::validate< Node >
     Validates the combination of filter and node. More...
     
    struct  Dune::TypeTree::SimpleFilter::apply< Child, new_index, old_index >
     Applies the filter to the given child node. More...
     
    struct  Dune::TypeTree::IndexFilter< indices >
     Filter class for FilteredCompositeNode that selects the children with the given indices. More...
     
    struct  Dune::TypeTree::filter< Filter >
     Adapter class that takes a SimpleFilter, validated it and turns it into an AdvancedFilter. More...
     
    struct  Dune::TypeTree::filter< Filter >::apply< Node, Children >
     Apply the filter. More...
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,29 +1,62 @@ │ │ │ │ │ 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 │ │ │ │ │ -utility.hh File Reference │ │ │ │ │ -#include │ │ │ │ │ +filters.hh File Reference │ │ │ │ │ #include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#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 │ │ │ │ │ _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_:_:_T_r_e_e_I_n_f_o_<_ _T_r_e_e_,_ _T_a_g_ _> │ │ │ │ │ -  Struct for obtaining some basic structural information about 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_:_:_F_i_l_t_e_r_E_n_t_r_y_<_ _n_e_w___k_,_ _o_l_d___k_ _> │ │ │ │ │ +  A filter entry describing the mapping of one child in the filtered │ │ │ │ │ + node. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_R_e_s_u_l_t_<_ _F_i_l_t_e_r_E_n_t_r_i_e_s_ _> │ │ │ │ │ +  The result of a filter. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_R_e_s_u_l_t_<_ _F_i_l_t_e_r_E_n_t_r_i_e_s_ _>_:_:_a_p_p_l_y_<_ _N_o_d_e_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r_T_a_g │ │ │ │ │ +  Tag describing a simple filter that can only decide whether or not to │ │ │ │ │ + include a single given child. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_d_v_a_n_c_e_d_F_i_l_t_e_r_T_a_g │ │ │ │ │ +  Tag describing an advanced filter that has full control over the │ │ │ │ │ + construction of the list of FilterEntries. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_d_v_a_n_c_e_d_F_i_l_t_e_r │ │ │ │ │ +  Base class for advanced filters. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_d_v_a_n_c_e_d_F_i_l_t_e_r_:_:_a_p_p_l_y_<_ _N_o_d_e_,_ _C_h_i_l_d_r_e_n_ _> │ │ │ │ │ +  Apply this filter to the given node and children. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r │ │ │ │ │ +  Default simple filter that accepts any node and leaves its child │ │ │ │ │ + structure unchanged. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r_:_:_v_a_l_i_d_a_t_e_<_ _N_o_d_e_ _> │ │ │ │ │ +  Validates the combination of filter and node. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r_:_:_a_p_p_l_y_<_ _C_h_i_l_d_,_ _n_e_w___i_n_d_e_x_,_ _o_l_d___i_n_d_e_x_ _> │ │ │ │ │ +  Applies the filter to the given child node. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_I_n_d_e_x_F_i_l_t_e_r_<_ _i_n_d_i_c_e_s_ _> │ │ │ │ │ +  Filter class for _F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e that selects the children with │ │ │ │ │ + the given indices. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_i_l_t_e_r_<_ _F_i_l_t_e_r_ _> │ │ │ │ │ +  Adapter class that takes a _S_i_m_p_l_e_F_i_l_t_e_r, validated it and turns it │ │ │ │ │ + into an _A_d_v_a_n_c_e_d_F_i_l_t_e_r. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_i_l_t_e_r_<_ _F_i_l_t_e_r_ _>_:_:_a_p_p_l_y_<_ _N_o_d_e_,_ _C_h_i_l_d_r_e_n_ _> │ │ │ │ │ +  Apply the filter. _M_o_r_e_._._. │ │ │ │ │   │ │ │ │ │ NNaammeessppaacceess │ │ │ │ │ namespace   _D_u_n_e │ │ │ │ │   │ │ │ │ │ namespace   _D_u_n_e_:_:_T_y_p_e_T_r_e_e │ │ │ │ │   │ │ │ │ │ =============================================================================== │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00047_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: utility.hh Source File │ │ │ │ +dune-typetree: filters.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,236 +74,261 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ -
    utility.hh
    │ │ │ │ +
    filters.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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_UTILITY_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_UTILITY_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_FILTERS_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_FILTERS_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <memory>
    │ │ │ │ -
    10#include <tuple>
    │ │ │ │ -
    11#include <type_traits>
    │ │ │ │ -
    12#include <utility>
    │ │ │ │ -
    13#include <algorithm>
    │ │ │ │ -
    14
    │ │ │ │ -
    15#include <dune/common/shared_ptr.hh>
    │ │ │ │ -
    16#include <dune/common/indices.hh>
    │ │ │ │ -
    17#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ -
    18#include <dune/typetree/nodetags.hh>
    │ │ │ │ -
    19
    │ │ │ │ -
    20namespace Dune {
    │ │ │ │ -
    21 namespace TypeTree {
    │ │ │ │ -
    22
    │ │ │ │ -
    27#ifndef DOXYGEN
    │ │ │ │ -
    28
    │ │ │ │ -
    29 template<typename T>
    │ │ │ │ -
    30 std::shared_ptr<T> convert_arg(const T& t)
    │ │ │ │ -
    31 {
    │ │ │ │ -
    32 return std::make_shared<T>(t);
    │ │ │ │ -
    33 }
    │ │ │ │ +
    9#include <tuple>
    │ │ │ │ +
    10
    │ │ │ │ +
    11#include <dune/common/typetraits.hh>
    │ │ │ │ +
    12
    │ │ │ │ +
    13namespace Dune {
    │ │ │ │ +
    14 namespace TypeTree {
    │ │ │ │ +
    15
    │ │ │ │ +
    22 template<std::size_t new_k, std::size_t old_k>
    │ │ │ │ +
    │ │ │ │ +
    23 struct FilterEntry
    │ │ │ │ +
    24 {
    │ │ │ │ +
    25
    │ │ │ │ +
    26#ifndef DOXYGEN
    │ │ │ │ +
    27
    │ │ │ │ +
    28 // The precise contents of this class is an implementation detail.
    │ │ │ │ +
    29
    │ │ │ │ +
    30 static const std::size_t filtered_index = new_k;
    │ │ │ │ +
    31 static const std::size_t original_index = old_k;
    │ │ │ │ +
    32
    │ │ │ │ +
    33#endif // DOXYGEN
    │ │ │ │
    34
    │ │ │ │ -
    35 template<typename T>
    │ │ │ │ -
    36 std::shared_ptr<T> convert_arg(T& t)
    │ │ │ │ -
    37 {
    │ │ │ │ -
    38 return stackobject_to_shared_ptr(t);
    │ │ │ │ -
    39 }
    │ │ │ │ -
    40
    │ │ │ │ -
    41 template<typename BaseType, typename T>
    │ │ │ │ -
    42 T& assertGridViewType(T& t)
    │ │ │ │ -
    43 {
    │ │ │ │ -
    44 static_assert((std::is_same<typename BaseType::Traits::GridViewType,
    │ │ │ │ -
    45 typename T::Traits::GridViewType>::value),
    │ │ │ │ -
    46 "GridViewType must be equal in all components of composite type");
    │ │ │ │ -
    47 return t;
    │ │ │ │ -
    48 }
    │ │ │ │ -
    49
    │ │ │ │ -
    50 // only bind to real rvalues
    │ │ │ │ -
    51 template<typename T>
    │ │ │ │ -
    52 typename std::enable_if<!std::is_lvalue_reference<T>::value,std::shared_ptr<T> >::type convert_arg(T&& t)
    │ │ │ │ -
    53 {
    │ │ │ │ -
    54 return std::make_shared<T>(std::forward<T>(t));
    │ │ │ │ -
    55 }
    │ │ │ │ -
    56
    │ │ │ │ -
    57
    │ │ │ │ -
    58 namespace Experimental {
    │ │ │ │ -
    59
    │ │ │ │ -
    68 template<class BinaryOp, class Arg>
    │ │ │ │ -
    69 constexpr decltype(auto)
    │ │ │ │ -
    70 left_fold(const BinaryOp& binary_op, Arg&& arg)
    │ │ │ │ -
    71 {
    │ │ │ │ -
    72 return std::forward<Arg>(arg);
    │ │ │ │ -
    73 }
    │ │ │ │ -
    74
    │ │ │ │ -
    96 template<class BinaryOp, class Init, class Arg0, class... Args>
    │ │ │ │ -
    97 constexpr decltype(auto)
    │ │ │ │ -
    98 left_fold(const BinaryOp& binary_op, Init&& init, Arg0&& arg_0, Args&&... args)
    │ │ │ │ -
    99 {
    │ │ │ │ -
    100 return left_fold(
    │ │ │ │ -
    101 binary_op,
    │ │ │ │ -
    102 binary_op(std::forward<Init>(init), std::forward<Arg0>(arg_0)),
    │ │ │ │ -
    103 std::forward<Args>(args)...);
    │ │ │ │ -
    104 }
    │ │ │ │ -
    105
    │ │ │ │ -
    106 } // namespace Experimental
    │ │ │ │ +
    35 };
    │ │ │ │ +
    │ │ │ │ +
    36
    │ │ │ │ +
    38 template<typename... FilterEntries>
    │ │ │ │ +
    │ │ │ │ +
    39 struct FilterResult
    │ │ │ │ +
    40 {
    │ │ │ │ +
    41
    │ │ │ │ +
    42 static const std::size_t size = sizeof...(FilterEntries);
    │ │ │ │ +
    43
    │ │ │ │ +
    44 typedef std::tuple<FilterEntries...> IndexMap;
    │ │ │ │ +
    45
    │ │ │ │ +
    46 template<typename Node>
    │ │ │ │ +
    │ │ │ │ +
    47 struct apply
    │ │ │ │ +
    48 {
    │ │ │ │ +
    49 typedef std::tuple<typename Node::template Child<FilterEntries::original_index>...> Children;
    │ │ │ │ +
    50 typedef std::tuple<typename Node::template Child<FilterEntries::original_index>::Type...> ChildTypes;
    │ │ │ │ +
    51 typedef std::tuple<std::shared_ptr<typename Node::template Child<FilterEntries::original_index>::Type>...> NodeStorage;
    │ │ │ │ +
    52 };
    │ │ │ │ +
    │ │ │ │ +
    53
    │ │ │ │ +
    54 };
    │ │ │ │ +
    │ │ │ │ +
    55
    │ │ │ │ +
    57 struct SimpleFilterTag {};
    │ │ │ │ +
    58
    │ │ │ │ +
    60 struct AdvancedFilterTag {};
    │ │ │ │ +
    61
    │ │ │ │ +
    62
    │ │ │ │ +
    │ │ │ │ +
    64 struct AdvancedFilter
    │ │ │ │ +
    65 {
    │ │ │ │ +
    66
    │ │ │ │ +
    68 typedef AdvancedFilterTag FilterTag;
    │ │ │ │ +
    69
    │ │ │ │ +
    70#ifdef DOXYGEN
    │ │ │ │ +
    71
    │ │ │ │ +
    73 template<typename Node, typename... Children>
    │ │ │ │ +
    │ │ │ │ +
    74 struct apply
    │ │ │ │ +
    75 {
    │ │ │ │ +
    77
    │ │ │ │ +
    80 typedef implementation-defined type;
    │ │ │ │ +
    81 };
    │ │ │ │ +
    │ │ │ │ +
    82
    │ │ │ │ +
    83#endif // DOXYGEN
    │ │ │ │ +
    84
    │ │ │ │ +
    85 };
    │ │ │ │ +
    │ │ │ │ +
    86
    │ │ │ │ +
    88
    │ │ │ │ +
    │ │ │ │ +
    93 struct SimpleFilter
    │ │ │ │ +
    94 {
    │ │ │ │ +
    95
    │ │ │ │ +
    97 typedef SimpleFilterTag FilterTag;
    │ │ │ │ +
    98
    │ │ │ │ +
    99
    │ │ │ │ +
    101 template<typename Node>
    │ │ │ │ +
    │ │ │ │ +
    102 struct validate
    │ │ │ │ +
    103 {
    │ │ │ │ +
    105 static const bool value = true;
    │ │ │ │ +
    106 };
    │ │ │ │ +
    │ │ │ │
    107
    │ │ │ │ -
    108
    │ │ │ │ -
    109#endif // DOXYGEN
    │ │ │ │ -
    110
    │ │ │ │ -
    112
    │ │ │ │ -
    119 template<typename Tree, typename Tag = StartTag>
    │ │ │ │ -
    │ │ │ │ -
    120 struct TreeInfo
    │ │ │ │ -
    121 {
    │ │ │ │ -
    122
    │ │ │ │ -
    123 private:
    │ │ │ │ -
    124 // Start the tree traversal
    │ │ │ │ -
    125 typedef TreeInfo<Tree,NodeTag<Tree>> NodeInfo;
    │ │ │ │ -
    126
    │ │ │ │ -
    127 public:
    │ │ │ │ -
    128
    │ │ │ │ -
    130 static const std::size_t depth = NodeInfo::depth;
    │ │ │ │ +
    109
    │ │ │ │ +
    117 template<typename Child, std::size_t new_index, std::size_t old_index>
    │ │ │ │ +
    │ │ │ │ +
    118 struct apply
    │ │ │ │ +
    119 {
    │ │ │ │ +
    121 static const bool value = true;
    │ │ │ │ +
    122 };
    │ │ │ │ +
    │ │ │ │ +
    123
    │ │ │ │ +
    124 };
    │ │ │ │ +
    │ │ │ │ +
    125
    │ │ │ │ +
    126 namespace {
    │ │ │ │ +
    127
    │ │ │ │ +
    128 // ********************************************************************************
    │ │ │ │ +
    129 // IndexFilter helpers
    │ │ │ │ +
    130 // ********************************************************************************
    │ │ │ │
    131
    │ │ │ │ -
    133 static const std::size_t nodeCount = NodeInfo::nodeCount;
    │ │ │ │ -
    134
    │ │ │ │ -
    136 static const std::size_t leafCount = NodeInfo::leafCount;
    │ │ │ │ -
    137
    │ │ │ │ -
    138 };
    │ │ │ │ -
    │ │ │ │ -
    139
    │ │ │ │ -
    140
    │ │ │ │ -
    141#ifndef DOXYGEN
    │ │ │ │ -
    142
    │ │ │ │ -
    143 // ********************************************************************************
    │ │ │ │ -
    144 // TreeInfo specializations for the different node types
    │ │ │ │ -
    145 // ********************************************************************************
    │ │ │ │ -
    146
    │ │ │ │ -
    147
    │ │ │ │ -
    148 // leaf node
    │ │ │ │ -
    149 template<typename Node>
    │ │ │ │ -
    150 struct TreeInfo<Node,LeafNodeTag>
    │ │ │ │ -
    151 {
    │ │ │ │ -
    152
    │ │ │ │ -
    153 static const std::size_t depth = 1;
    │ │ │ │ -
    154
    │ │ │ │ -
    155 static const std::size_t nodeCount = 1;
    │ │ │ │ +
    132 template<typename Node, std::size_t new_index, std::size_t... indices>
    │ │ │ │ +
    133 struct index_filter_helper
    │ │ │ │ +
    134 {
    │ │ │ │ +
    135 template<typename... FilterEntries>
    │ │ │ │ +
    136 struct apply
    │ │ │ │ +
    137 {
    │ │ │ │ +
    138 typedef FilterResult<FilterEntries...> type;
    │ │ │ │ +
    139 };
    │ │ │ │ +
    140 };
    │ │ │ │ +
    141
    │ │ │ │ +
    142 template<typename Node, std::size_t new_index, std::size_t old_index, std::size_t... indices>
    │ │ │ │ +
    143 struct index_filter_helper<Node,new_index,old_index,indices...>
    │ │ │ │ +
    144 {
    │ │ │ │ +
    145 template<typename... FilterEntries>
    │ │ │ │ +
    146 struct apply
    │ │ │ │ +
    147 : public index_filter_helper<Node,new_index+1,indices...>::template apply<FilterEntries...,
    │ │ │ │ +
    148 FilterEntry<new_index,
    │ │ │ │ +
    149 old_index>
    │ │ │ │ +
    150 >
    │ │ │ │ +
    151 {};
    │ │ │ │ +
    152 };
    │ │ │ │ +
    153
    │ │ │ │ +
    154 } // anonymous namespace
    │ │ │ │ +
    155
    │ │ │ │
    156
    │ │ │ │ -
    157 static const std::size_t leafCount = 1;
    │ │ │ │ -
    158
    │ │ │ │ -
    159 };
    │ │ │ │ -
    160
    │ │ │ │ -
    161
    │ │ │ │ -
    162 // power node - exploit the fact that all children are identical
    │ │ │ │ -
    163 template<typename Node>
    │ │ │ │ -
    164 struct TreeInfo<Node,PowerNodeTag>
    │ │ │ │ -
    165 {
    │ │ │ │ -
    166
    │ │ │ │ -
    167 typedef TreeInfo<typename Node::ChildType,NodeTag<typename Node::ChildType>> ChildInfo;
    │ │ │ │ -
    168
    │ │ │ │ -
    169 static const std::size_t depth = 1 + ChildInfo::depth;
    │ │ │ │ +
    158 template<std::size_t... indices>
    │ │ │ │ +
    │ │ │ │ +
    159 struct IndexFilter
    │ │ │ │ +
    160 : public AdvancedFilter
    │ │ │ │ +
    161 {
    │ │ │ │ +
    162
    │ │ │ │ +
    163#ifndef DOXYGEN
    │ │ │ │ +
    164
    │ │ │ │ +
    165 template<typename Node, typename... Children>
    │ │ │ │ +
    166 struct apply
    │ │ │ │ +
    167 {
    │ │ │ │ +
    168 typedef typename index_filter_helper<Node,0,indices...>::template apply<>::type type;
    │ │ │ │ +
    169 };
    │ │ │ │
    170
    │ │ │ │ -
    171 static const std::size_t nodeCount = 1 + StaticDegree<Node>::value * ChildInfo::nodeCount;
    │ │ │ │ +
    171#endif // DOXYGEN
    │ │ │ │
    172
    │ │ │ │ -
    173 static const std::size_t leafCount = StaticDegree<Node>::value * ChildInfo::leafCount;
    │ │ │ │ +
    173 };
    │ │ │ │ +
    │ │ │ │
    174
    │ │ │ │ -
    175 };
    │ │ │ │ -
    176
    │ │ │ │ -
    177
    │ │ │ │ -
    178 namespace {
    │ │ │ │ -
    179
    │ │ │ │ -
    180 // TMP for iterating over the children of a composite node
    │ │ │ │ -
    181 // identical for both composite node implementations
    │ │ │ │ -
    182 template<typename Node, std::size_t k, std::size_t n>
    │ │ │ │ -
    183 struct generic_compositenode_children_info
    │ │ │ │ -
    184 {
    │ │ │ │ -
    185
    │ │ │ │ -
    186 typedef generic_compositenode_children_info<Node,k+1,n> NextChild;
    │ │ │ │ -
    187
    │ │ │ │ -
    188 // extract child info
    │ │ │ │ -
    189 typedef typename Node::template Child<k>::Type Child;
    │ │ │ │ -
    190 typedef NodeTag<Child> ChildTag;
    │ │ │ │ -
    191 typedef TreeInfo<Child,ChildTag> ChildInfo;
    │ │ │ │ +
    175
    │ │ │ │ +
    176 // ********************************************************************************
    │ │ │ │ +
    177 // filter: Wrapper class for turning a simple filter into an advanced filter
    │ │ │ │ +
    178 // usable by FilteredCompositeNode
    │ │ │ │ +
    179 // ********************************************************************************
    │ │ │ │ +
    180
    │ │ │ │ +
    181 namespace {
    │ │ │ │ +
    182
    │ │ │ │ +
    183 template<typename Filter, std::size_t new_k, std::size_t old_k, typename... tail>
    │ │ │ │ +
    184 struct filter_helper
    │ │ │ │ +
    185 {
    │ │ │ │ +
    186 template<typename... FilterDescriptors>
    │ │ │ │ +
    187 struct apply
    │ │ │ │ +
    188 {
    │ │ │ │ +
    189 typedef FilterResult<FilterDescriptors...> type;
    │ │ │ │ +
    190 };
    │ │ │ │ +
    191 };
    │ │ │ │
    192
    │ │ │ │ -
    193 // combine information of current child with info about following children
    │ │ │ │ -
    194 static const std::size_t maxDepth = ChildInfo::depth > NextChild::maxDepth ? ChildInfo::depth : NextChild::maxDepth;
    │ │ │ │ -
    195
    │ │ │ │ -
    196 static const std::size_t nodeCount = ChildInfo::nodeCount + NextChild::nodeCount;
    │ │ │ │ -
    197
    │ │ │ │ -
    198 static const std::size_t leafCount = ChildInfo::leafCount + NextChild::leafCount;
    │ │ │ │ -
    199
    │ │ │ │ -
    200 };
    │ │ │ │ -
    201
    │ │ │ │ -
    202 // End of recursion
    │ │ │ │ -
    203 template<typename Node, std::size_t n>
    │ │ │ │ -
    204 struct generic_compositenode_children_info<Node,n,n>
    │ │ │ │ -
    205 {
    │ │ │ │ -
    206 static const std::size_t maxDepth = 0;
    │ │ │ │ -
    207
    │ │ │ │ -
    208 static const std::size_t nodeCount = 0;
    │ │ │ │ -
    209
    │ │ │ │ -
    210 static const std::size_t leafCount = 0;
    │ │ │ │ -
    211 };
    │ │ │ │ -
    212
    │ │ │ │ -
    213 } // anonymous namespace
    │ │ │ │ -
    214
    │ │ │ │ -
    215
    │ │ │ │ -
    216 // Struct for building information about composite node
    │ │ │ │ -
    217 template<typename Node>
    │ │ │ │ -
    218 struct GenericCompositeNodeInfo
    │ │ │ │ -
    219 {
    │ │ │ │ +
    193 template<typename Filter, std::size_t new_k, std::size_t old_k, typename child, typename... tail>
    │ │ │ │ +
    194 struct filter_helper<Filter,new_k,old_k,child,tail...>
    │ │ │ │ +
    195 {
    │ │ │ │ +
    196
    │ │ │ │ +
    197 template<typename... FilterDescriptors>
    │ │ │ │ +
    198 struct apply
    │ │ │ │ +
    199 : public std::conditional<Filter::template apply<child,new_k,old_k>::value,
    │ │ │ │ +
    200 typename filter_helper<Filter,new_k+1,old_k+1,tail...>::template apply<FilterDescriptors...,FilterEntry<new_k,old_k> >,
    │ │ │ │ +
    201 typename filter_helper<Filter,new_k,old_k+1,tail...>::template apply<FilterDescriptors...>
    │ │ │ │ +
    202 >::type
    │ │ │ │ +
    203 {};
    │ │ │ │ +
    204
    │ │ │ │ +
    205 };
    │ │ │ │ +
    206
    │ │ │ │ +
    207 } // anonymous namespace
    │ │ │ │ +
    208
    │ │ │ │ +
    210 template<typename Filter>
    │ │ │ │ +
    │ │ │ │ +
    211 struct filter
    │ │ │ │ +
    212 {
    │ │ │ │ +
    213
    │ │ │ │ +
    215 template<typename Node, typename... Children>
    │ │ │ │ +
    │ │ │ │ +
    216 struct apply
    │ │ │ │ +
    217 {
    │ │ │ │ +
    218
    │ │ │ │ +
    219 static_assert((Filter::template validate<Node>::value),"Invalid simple filter");
    │ │ │ │
    220
    │ │ │ │ -
    221 typedef generic_compositenode_children_info<Node,0,StaticDegree<Node>::value> Children;
    │ │ │ │ +
    221 typedef typename filter_helper<Filter,0,0,Children...>::template apply<>::type type;
    │ │ │ │
    222
    │ │ │ │ -
    223 static const std::size_t depth = 1 + Children::maxDepth;
    │ │ │ │ +
    223 };
    │ │ │ │ +
    │ │ │ │
    224
    │ │ │ │ -
    225 static const std::size_t nodeCount = 1 + Children::nodeCount;
    │ │ │ │ +
    225 };
    │ │ │ │ +
    │ │ │ │
    226
    │ │ │ │ -
    227 static const std::size_t leafCount = Children::leafCount;
    │ │ │ │
    228
    │ │ │ │ -
    229 };
    │ │ │ │ -
    230
    │ │ │ │ +
    229 } // namespace TypeTree
    │ │ │ │ +
    230} //namespace Dune
    │ │ │ │
    231
    │ │ │ │ -
    232 // CompositeNode: delegate to GenericCompositeNodeInfo
    │ │ │ │ -
    233 template<typename Node>
    │ │ │ │ -
    234 struct TreeInfo<Node,CompositeNodeTag>
    │ │ │ │ -
    235 : public GenericCompositeNodeInfo<Node>
    │ │ │ │ -
    236 {};
    │ │ │ │ -
    237
    │ │ │ │ -
    238
    │ │ │ │ -
    239#endif // DOXYGEN
    │ │ │ │ -
    240
    │ │ │ │ -
    241
    │ │ │ │ -
    242 using Dune::index_constant;
    │ │ │ │ -
    243 namespace Indices = Dune::Indices;
    │ │ │ │ -
    244
    │ │ │ │ -
    246
    │ │ │ │ -
    247 } // namespace TypeTree
    │ │ │ │ -
    248} //namespace Dune
    │ │ │ │ -
    249
    │ │ │ │ -
    250#endif // DUNE_TYPETREE_UTILITY_HH
    │ │ │ │ - │ │ │ │ - │ │ │ │ +
    232#endif // DUNE_TYPETREE_FILTERS_HH
    │ │ │ │ +
    Dune::TypeTree::child
    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
    │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::Experimental::Info::leafCount
    auto leafCount(const Tree &tree)
    The number of leaf nodes in the Tree.
    Definition visitor.hh:532
    │ │ │ │ -
    Dune::TypeTree::Experimental::Info::nodeCount
    auto nodeCount(const Tree &tree)
    The total number of nodes in the Tree.
    Definition visitor.hh:524
    │ │ │ │ -
    Dune::TypeTree::Experimental::Info::depth
    auto depth(const Tree &tree)
    The depth of the TypeTree.
    Definition visitor.hh:508
    │ │ │ │ -
    Dune::TypeTree::LeafNodeTag
    Tag designating a leaf node.
    Definition nodetags.hh:18
    │ │ │ │ -
    Dune::TypeTree::TreeInfo
    Struct for obtaining some basic structural information about a TypeTree.
    Definition utility.hh:121
    │ │ │ │ -
    Dune::TypeTree::TreeInfo::leafCount
    static const std::size_t leafCount
    The number of leaf nodes in the TypeTree.
    Definition utility.hh:136
    │ │ │ │ -
    Dune::TypeTree::TreeInfo::depth
    static const std::size_t depth
    The depth of the TypeTree.
    Definition utility.hh:130
    │ │ │ │ -
    Dune::TypeTree::TreeInfo::nodeCount
    static const std::size_t nodeCount
    The total number of nodes in the TypeTree.
    Definition utility.hh:133
    │ │ │ │ +
    Dune::TypeTree::FilterEntry
    A filter entry describing the mapping of one child in the filtered node.
    Definition filters.hh:24
    │ │ │ │ +
    Dune::TypeTree::FilterResult
    The result of a filter.
    Definition filters.hh:40
    │ │ │ │ +
    Dune::TypeTree::FilterResult::IndexMap
    std::tuple< FilterEntries... > IndexMap
    Definition filters.hh:44
    │ │ │ │ +
    Dune::TypeTree::FilterResult::size
    static const std::size_t size
    Definition filters.hh:42
    │ │ │ │ +
    Dune::TypeTree::FilterResult::apply
    Definition filters.hh:48
    │ │ │ │ +
    Dune::TypeTree::FilterResult::apply::Children
    std::tuple< typename Node::template Child< FilterEntries::original_index >... > Children
    Definition filters.hh:49
    │ │ │ │ +
    Dune::TypeTree::FilterResult::apply::ChildTypes
    std::tuple< typename Node::template Child< FilterEntries::original_index >::Type... > ChildTypes
    Definition filters.hh:50
    │ │ │ │ +
    Dune::TypeTree::FilterResult::apply::NodeStorage
    std::tuple< std::shared_ptr< typename Node::template Child< FilterEntries::original_index >::Type >... > NodeStorage
    Definition filters.hh:51
    │ │ │ │ +
    Dune::TypeTree::SimpleFilterTag
    Tag describing a simple filter that can only decide whether or not to include a single given child.
    Definition filters.hh:57
    │ │ │ │ +
    Dune::TypeTree::AdvancedFilterTag
    Tag describing an advanced filter that has full control over the construction of the list of FilterEn...
    Definition filters.hh:60
    │ │ │ │ +
    Dune::TypeTree::AdvancedFilter
    Base class for advanced filters.
    Definition filters.hh:65
    │ │ │ │ +
    Dune::TypeTree::AdvancedFilter::FilterTag
    AdvancedFilterTag FilterTag
    Filter tag for deciding on filter application mechanism.
    Definition filters.hh:68
    │ │ │ │ +
    Dune::TypeTree::AdvancedFilter::apply
    Apply this filter to the given node and children.
    Definition filters.hh:75
    │ │ │ │ +
    Dune::TypeTree::AdvancedFilter::apply::type
    implementation defined type
    The result of the filtering process.
    Definition filters.hh:80
    │ │ │ │ +
    Dune::TypeTree::SimpleFilter
    Default simple filter that accepts any node and leaves its child structure unchanged.
    Definition filters.hh:94
    │ │ │ │ +
    Dune::TypeTree::SimpleFilter::FilterTag
    SimpleFilterTag FilterTag
    Filter tag for deciding on filter application mechanism.
    Definition filters.hh:97
    │ │ │ │ +
    Dune::TypeTree::SimpleFilter::validate
    Validates the combination of filter and node.
    Definition filters.hh:103
    │ │ │ │ +
    Dune::TypeTree::SimpleFilter::validate::value
    static const bool value
    True if the combination of filter and node is valid.
    Definition filters.hh:105
    │ │ │ │ +
    Dune::TypeTree::SimpleFilter::apply
    Applies the filter to the given child node.
    Definition filters.hh:119
    │ │ │ │ +
    Dune::TypeTree::SimpleFilter::apply::value
    static const bool value
    True if the child will be included in the filtered node.
    Definition filters.hh:121
    │ │ │ │ +
    Dune::TypeTree::IndexFilter
    Filter class for FilteredCompositeNode that selects the children with the given indices.
    Definition filters.hh:161
    │ │ │ │ +
    Dune::TypeTree::filter
    Adapter class that takes a SimpleFilter, validated it and turns it into an AdvancedFilter.
    Definition filters.hh:212
    │ │ │ │ +
    Dune::TypeTree::filter::apply
    Apply the filter.
    Definition filters.hh:217
    │ │ │ │ +
    Dune::TypeTree::filter::apply::type
    filter_helper< Filter, 0, 0, Children... >::template apply ::type type
    Definition filters.hh:221
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,265 +1,320 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -utility.hh │ │ │ │ │ +filters.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_UTILITY_HH │ │ │ │ │ -7#define DUNE_TYPETREE_UTILITY_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_FILTERS_HH │ │ │ │ │ +7#define DUNE_TYPETREE_FILTERS_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include │ │ │ │ │ -10#include │ │ │ │ │ -11#include │ │ │ │ │ -12#include │ │ │ │ │ -13#include │ │ │ │ │ -14 │ │ │ │ │ -15#include │ │ │ │ │ -16#include │ │ │ │ │ -17#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> │ │ │ │ │ -18#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ -19 │ │ │ │ │ -20namespace _D_u_n_e { │ │ │ │ │ -21 namespace TypeTree { │ │ │ │ │ -22 │ │ │ │ │ -27#ifndef DOXYGEN │ │ │ │ │ -28 │ │ │ │ │ -29 template │ │ │ │ │ -30 std::shared_ptr convert_arg(const T& t) │ │ │ │ │ -31 { │ │ │ │ │ -32 return std::make_shared(t); │ │ │ │ │ -33 } │ │ │ │ │ +9#include │ │ │ │ │ +10 │ │ │ │ │ +11#include │ │ │ │ │ +12 │ │ │ │ │ +13namespace _D_u_n_e { │ │ │ │ │ +14 namespace TypeTree { │ │ │ │ │ +15 │ │ │ │ │ +22 template │ │ │ │ │ +_2_3 struct _F_i_l_t_e_r_E_n_t_r_y │ │ │ │ │ +24 { │ │ │ │ │ +25 │ │ │ │ │ +26#ifndef DOXYGEN │ │ │ │ │ +27 │ │ │ │ │ +28 // The precise contents of this class is an implementation detail. │ │ │ │ │ +29 │ │ │ │ │ +30 static const std::size_t filtered_index = new_k; │ │ │ │ │ +31 static const std::size_t original_index = old_k; │ │ │ │ │ +32 │ │ │ │ │ +33#endif // DOXYGEN │ │ │ │ │ 34 │ │ │ │ │ -35 template │ │ │ │ │ -36 std::shared_ptr convert_arg(T& t) │ │ │ │ │ -37 { │ │ │ │ │ -38 return stackobject_to_shared_ptr(t); │ │ │ │ │ -39 } │ │ │ │ │ -40 │ │ │ │ │ -41 template │ │ │ │ │ -42 T& assertGridViewType(T& t) │ │ │ │ │ -43 { │ │ │ │ │ -44 static_assert((std::is_same::value), │ │ │ │ │ -46 "GridViewType must be equal in all components of composite type"); │ │ │ │ │ -47 return t; │ │ │ │ │ -48 } │ │ │ │ │ -49 │ │ │ │ │ -50 // only bind to real rvalues │ │ │ │ │ -51 template │ │ │ │ │ -52 typename std::enable_if::value,std:: │ │ │ │ │ -shared_ptr >::type convert_arg(T&& t) │ │ │ │ │ -53 { │ │ │ │ │ -54 return std::make_shared(std::forward(t)); │ │ │ │ │ -55 } │ │ │ │ │ -56 │ │ │ │ │ -57 │ │ │ │ │ -58 namespace Experimental { │ │ │ │ │ -59 │ │ │ │ │ -68 template │ │ │ │ │ -69 constexpr decltype(auto) │ │ │ │ │ -70 left_fold(const BinaryOp& binary_op, Arg&& arg) │ │ │ │ │ -71 { │ │ │ │ │ -72 return std::forward(arg); │ │ │ │ │ -73 } │ │ │ │ │ -74 │ │ │ │ │ -96 template │ │ │ │ │ -97 constexpr decltype(auto) │ │ │ │ │ -98 left_fold(const BinaryOp& binary_op, Init&& init, Arg0&& arg_0, Args&&... │ │ │ │ │ -args) │ │ │ │ │ -99 { │ │ │ │ │ -100 return left_fold( │ │ │ │ │ -101 binary_op, │ │ │ │ │ -102 binary_op(std::forward(init), std::forward(arg_0)), │ │ │ │ │ -103 std::forward(args)...); │ │ │ │ │ -104 } │ │ │ │ │ -105 │ │ │ │ │ -106 } // namespace Experimental │ │ │ │ │ +35 }; │ │ │ │ │ +36 │ │ │ │ │ +38 template │ │ │ │ │ +_3_9 struct _F_i_l_t_e_r_R_e_s_u_l_t │ │ │ │ │ +40 { │ │ │ │ │ +41 │ │ │ │ │ +_4_2 static const std::size_t _s_i_z_e = sizeof...(FilterEntries); │ │ │ │ │ +43 │ │ │ │ │ +_4_4 typedef std::tuple _I_n_d_e_x_M_a_p; │ │ │ │ │ +45 │ │ │ │ │ +46 template │ │ │ │ │ +_4_7 struct _a_p_p_l_y │ │ │ │ │ +48 { │ │ │ │ │ +_4_9 typedef std::tuple...> _C_h_i_l_d_r_e_n; │ │ │ │ │ +_5_0 typedef std::tuple::Type...> _C_h_i_l_d_T_y_p_e_s; │ │ │ │ │ +_5_1 typedef std::tuple::Type>...> _N_o_d_e_S_t_o_r_a_g_e; │ │ │ │ │ +52 }; │ │ │ │ │ +53 │ │ │ │ │ +54 }; │ │ │ │ │ +55 │ │ │ │ │ +_5_7 struct _S_i_m_p_l_e_F_i_l_t_e_r_T_a_g {}; │ │ │ │ │ +58 │ │ │ │ │ +_6_0 struct _A_d_v_a_n_c_e_d_F_i_l_t_e_r_T_a_g {}; │ │ │ │ │ +61 │ │ │ │ │ +62 │ │ │ │ │ +_6_4 struct _A_d_v_a_n_c_e_d_F_i_l_t_e_r │ │ │ │ │ +65 { │ │ │ │ │ +66 │ │ │ │ │ +_6_8 typedef _A_d_v_a_n_c_e_d_F_i_l_t_e_r_T_a_g _F_i_l_t_e_r_T_a_g; │ │ │ │ │ +69 │ │ │ │ │ +70#ifdef DOXYGEN │ │ │ │ │ +71 │ │ │ │ │ +73 template │ │ │ │ │ +_7_4 struct _a_p_p_l_y │ │ │ │ │ +75 { │ │ │ │ │ +77 │ │ │ │ │ +_8_0 typedef implementation-defined _t_y_p_e; │ │ │ │ │ +81 }; │ │ │ │ │ +82 │ │ │ │ │ +83#endif // DOXYGEN │ │ │ │ │ +84 │ │ │ │ │ +85 }; │ │ │ │ │ +86 │ │ │ │ │ +88 │ │ │ │ │ +_9_3 struct _S_i_m_p_l_e_F_i_l_t_e_r │ │ │ │ │ +94 { │ │ │ │ │ +95 │ │ │ │ │ +_9_7 typedef _S_i_m_p_l_e_F_i_l_t_e_r_T_a_g _F_i_l_t_e_r_T_a_g; │ │ │ │ │ +98 │ │ │ │ │ +99 │ │ │ │ │ +101 template │ │ │ │ │ +_1_0_2 struct _v_a_l_i_d_a_t_e │ │ │ │ │ +103 { │ │ │ │ │ +_1_0_5 static const bool _v_a_l_u_e = true; │ │ │ │ │ +106 }; │ │ │ │ │ 107 │ │ │ │ │ -108 │ │ │ │ │ -109#endif // DOXYGEN │ │ │ │ │ -110 │ │ │ │ │ -112 │ │ │ │ │ -119 template │ │ │ │ │ -_1_2_0 struct _T_r_e_e_I_n_f_o │ │ │ │ │ -121 { │ │ │ │ │ -122 │ │ │ │ │ -123 private: │ │ │ │ │ -124 // Start the tree traversal │ │ │ │ │ -125 typedef _T_r_e_e_I_n_f_o_<_T_r_e_e_,_N_o_d_e_T_a_g_<_T_r_e_e_>> _N_o_d_e_I_n_f_o; │ │ │ │ │ -126 │ │ │ │ │ -127 public: │ │ │ │ │ -128 │ │ │ │ │ -_1_3_0 static const std::size_t _d_e_p_t_h = _N_o_d_e_I_n_f_o_:_:_d_e_p_t_h; │ │ │ │ │ -131 │ │ │ │ │ -_1_3_3 static const std::size_t _n_o_d_e_C_o_u_n_t = _N_o_d_e_I_n_f_o_:_:_n_o_d_e_C_o_u_n_t; │ │ │ │ │ -134 │ │ │ │ │ -_1_3_6 static const std::size_t _l_e_a_f_C_o_u_n_t = _N_o_d_e_I_n_f_o_:_:_l_e_a_f_C_o_u_n_t; │ │ │ │ │ -137 │ │ │ │ │ -138 }; │ │ │ │ │ -139 │ │ │ │ │ -140 │ │ │ │ │ -141#ifndef DOXYGEN │ │ │ │ │ -142 │ │ │ │ │ -143 / │ │ │ │ │ +109 │ │ │ │ │ +117 template │ │ │ │ │ +_1_1_8 struct _a_p_p_l_y │ │ │ │ │ +119 { │ │ │ │ │ +_1_2_1 static const bool _v_a_l_u_e = true; │ │ │ │ │ +122 }; │ │ │ │ │ +123 │ │ │ │ │ +124 }; │ │ │ │ │ +125 │ │ │ │ │ +126 namespace { │ │ │ │ │ +127 │ │ │ │ │ +128 / │ │ │ │ │ / │ │ │ │ │ ******************************************************************************** │ │ │ │ │ -144 // TreeInfo specializations for the different node types │ │ │ │ │ -145 / │ │ │ │ │ +129 // IndexFilter helpers │ │ │ │ │ +130 / │ │ │ │ │ / │ │ │ │ │ ******************************************************************************** │ │ │ │ │ -146 │ │ │ │ │ -147 │ │ │ │ │ -148 // leaf node │ │ │ │ │ -149 template │ │ │ │ │ -150 struct _T_r_e_e_I_n_f_o │ │ │ │ │ -151 { │ │ │ │ │ -152 │ │ │ │ │ -153 static const std::size_t _d_e_p_t_h = 1; │ │ │ │ │ -154 │ │ │ │ │ -155 static const std::size_t _n_o_d_e_C_o_u_n_t = 1; │ │ │ │ │ +131 │ │ │ │ │ +132 template │ │ │ │ │ +133 struct index_filter_helper │ │ │ │ │ +134 { │ │ │ │ │ +135 template │ │ │ │ │ +136 struct apply │ │ │ │ │ +137 { │ │ │ │ │ +138 typedef _F_i_l_t_e_r_R_e_s_u_l_t type; │ │ │ │ │ +139 }; │ │ │ │ │ +140 }; │ │ │ │ │ +141 │ │ │ │ │ +142 template │ │ │ │ │ +143 struct index_filter_helper │ │ │ │ │ +144 { │ │ │ │ │ +145 template │ │ │ │ │ +146 struct apply │ │ │ │ │ +147 : public index_filter_helper::template │ │ │ │ │ +apply │ │ │ │ │ +150 > │ │ │ │ │ +151 {}; │ │ │ │ │ +152 }; │ │ │ │ │ +153 │ │ │ │ │ +154 } // anonymous namespace │ │ │ │ │ +155 │ │ │ │ │ 156 │ │ │ │ │ -157 static const std::size_t _l_e_a_f_C_o_u_n_t = 1; │ │ │ │ │ -158 │ │ │ │ │ -159 }; │ │ │ │ │ -160 │ │ │ │ │ -161 │ │ │ │ │ -162 // power node - exploit the fact that all children are identical │ │ │ │ │ -163 template │ │ │ │ │ -164 struct TreeInfo │ │ │ │ │ -165 { │ │ │ │ │ -166 │ │ │ │ │ -167 typedef TreeInfo> ChildInfo; │ │ │ │ │ -168 │ │ │ │ │ -169 static const std::size_t _d_e_p_t_h = 1 + ChildInfo::depth; │ │ │ │ │ +158 template │ │ │ │ │ +_1_5_9 struct _I_n_d_e_x_F_i_l_t_e_r │ │ │ │ │ +160 : public _A_d_v_a_n_c_e_d_F_i_l_t_e_r │ │ │ │ │ +161 { │ │ │ │ │ +162 │ │ │ │ │ +163#ifndef DOXYGEN │ │ │ │ │ +164 │ │ │ │ │ +165 template │ │ │ │ │ +166 struct _a_p_p_l_y │ │ │ │ │ +167 { │ │ │ │ │ +168 typedef typename index_filter_helper::template _a_p_p_l_y_<_>_:_: │ │ │ │ │ +_t_y_p_e _t_y_p_e; │ │ │ │ │ +169 }; │ │ │ │ │ 170 │ │ │ │ │ -171 static const std::size_t _n_o_d_e_C_o_u_n_t = 1 + StaticDegree::value * │ │ │ │ │ -ChildInfo::nodeCount; │ │ │ │ │ +171#endif // DOXYGEN │ │ │ │ │ 172 │ │ │ │ │ -173 static const std::size_t _l_e_a_f_C_o_u_n_t = StaticDegree::value * │ │ │ │ │ -ChildInfo::leafCount; │ │ │ │ │ +173 }; │ │ │ │ │ 174 │ │ │ │ │ -175 }; │ │ │ │ │ -176 │ │ │ │ │ -177 │ │ │ │ │ -178 namespace { │ │ │ │ │ -179 │ │ │ │ │ -180 // TMP for iterating over the children of a composite node │ │ │ │ │ -181 // identical for both composite node implementations │ │ │ │ │ -182 template │ │ │ │ │ -183 struct generic_compositenode_children_info │ │ │ │ │ -184 { │ │ │ │ │ -185 │ │ │ │ │ -186 typedef generic_compositenode_children_info NextChild; │ │ │ │ │ -187 │ │ │ │ │ -188 // extract child info │ │ │ │ │ -189 typedef typename Node::template Child::Type Child; │ │ │ │ │ -190 typedef NodeTag ChildTag; │ │ │ │ │ -191 typedef TreeInfo ChildInfo; │ │ │ │ │ +175 │ │ │ │ │ +176 / │ │ │ │ │ +/ │ │ │ │ │ +******************************************************************************** │ │ │ │ │ +177 // filter: Wrapper class for turning a simple filter into an advanced │ │ │ │ │ +filter │ │ │ │ │ +178 // usable by FilteredCompositeNode │ │ │ │ │ +179 / │ │ │ │ │ +/ │ │ │ │ │ +******************************************************************************** │ │ │ │ │ +180 │ │ │ │ │ +181 namespace { │ │ │ │ │ +182 │ │ │ │ │ +183 template │ │ │ │ │ +184 struct filter_helper │ │ │ │ │ +185 { │ │ │ │ │ +186 template │ │ │ │ │ +187 struct apply │ │ │ │ │ +188 { │ │ │ │ │ +189 typedef _F_i_l_t_e_r_R_e_s_u_l_t type; │ │ │ │ │ +190 }; │ │ │ │ │ +191 }; │ │ │ │ │ 192 │ │ │ │ │ -193 // combine information of current child with info about following children │ │ │ │ │ -194 static const std::size_t maxDepth = ChildInfo::depth > NextChild::maxDepth │ │ │ │ │ -? ChildInfo::depth : NextChild::maxDepth; │ │ │ │ │ -195 │ │ │ │ │ -196 static const std::size_t nodeCount = ChildInfo::nodeCount + NextChild:: │ │ │ │ │ -nodeCount; │ │ │ │ │ -197 │ │ │ │ │ -198 static const std::size_t leafCount = ChildInfo::leafCount + NextChild:: │ │ │ │ │ -leafCount; │ │ │ │ │ -199 │ │ │ │ │ -200 }; │ │ │ │ │ -201 │ │ │ │ │ -202 // End of recursion │ │ │ │ │ -203 template │ │ │ │ │ -204 struct generic_compositenode_children_info │ │ │ │ │ -205 { │ │ │ │ │ -206 static const std::size_t maxDepth = 0; │ │ │ │ │ -207 │ │ │ │ │ -208 static const std::size_t _n_o_d_e_C_o_u_n_t = 0; │ │ │ │ │ -209 │ │ │ │ │ -210 static const std::size_t _l_e_a_f_C_o_u_n_t = 0; │ │ │ │ │ -211 }; │ │ │ │ │ -212 │ │ │ │ │ -213 } // anonymous namespace │ │ │ │ │ -214 │ │ │ │ │ -215 │ │ │ │ │ -216 // Struct for building information about composite node │ │ │ │ │ -217 template │ │ │ │ │ -218 struct GenericCompositeNodeInfo │ │ │ │ │ -219 { │ │ │ │ │ +193 template │ │ │ │ │ +194 struct filter_helper │ │ │ │ │ +195 { │ │ │ │ │ +196 │ │ │ │ │ +197 template │ │ │ │ │ +198 struct apply │ │ │ │ │ +199 : public std::conditional::value, │ │ │ │ │ +200 typename filter_helper::template │ │ │ │ │ +apply >, │ │ │ │ │ +201 typename filter_helper::template │ │ │ │ │ +apply │ │ │ │ │ +202 >::type │ │ │ │ │ +203 {}; │ │ │ │ │ +204 │ │ │ │ │ +205 }; │ │ │ │ │ +206 │ │ │ │ │ +207 } // anonymous namespace │ │ │ │ │ +208 │ │ │ │ │ +210 template │ │ │ │ │ +_2_1_1 struct _f_i_l_t_e_r │ │ │ │ │ +212 { │ │ │ │ │ +213 │ │ │ │ │ +215 template │ │ │ │ │ +_2_1_6 struct _a_p_p_l_y │ │ │ │ │ +217 { │ │ │ │ │ +218 │ │ │ │ │ +219 static_assert((Filter::template validate::value),"Invalid simple │ │ │ │ │ +filter"); │ │ │ │ │ 220 │ │ │ │ │ -221 typedef generic_compositenode_children_info:: │ │ │ │ │ -value> Children; │ │ │ │ │ +_2_2_1 typedef typename filter_helper::template _a_p_p_l_y_<_>_:_: │ │ │ │ │ +_t_y_p_e _t_y_p_e; │ │ │ │ │ 222 │ │ │ │ │ -223 static const std::size_t _d_e_p_t_h = 1 + Children::maxDepth; │ │ │ │ │ +223 }; │ │ │ │ │ 224 │ │ │ │ │ -225 static const std::size_t _n_o_d_e_C_o_u_n_t = 1 + Children::nodeCount; │ │ │ │ │ +225 }; │ │ │ │ │ 226 │ │ │ │ │ -227 static const std::size_t _l_e_a_f_C_o_u_n_t = Children::leafCount; │ │ │ │ │ 228 │ │ │ │ │ -229 }; │ │ │ │ │ -230 │ │ │ │ │ +229 } // namespace TypeTree │ │ │ │ │ +230} //namespace Dune │ │ │ │ │ 231 │ │ │ │ │ -232 // CompositeNode: delegate to GenericCompositeNodeInfo │ │ │ │ │ -233 template │ │ │ │ │ -234 struct TreeInfo │ │ │ │ │ -235 : public GenericCompositeNodeInfo │ │ │ │ │ -236 {}; │ │ │ │ │ -237 │ │ │ │ │ -238 │ │ │ │ │ -239#endif // DOXYGEN │ │ │ │ │ -240 │ │ │ │ │ -241 │ │ │ │ │ -242 using Dune::index_constant; │ │ │ │ │ -243 namespace Indices = Dune::Indices; │ │ │ │ │ -244 │ │ │ │ │ -246 │ │ │ │ │ -247 } // namespace TypeTree │ │ │ │ │ -248} //namespace Dune │ │ │ │ │ -249 │ │ │ │ │ -250#endif // DUNE_TYPETREE_UTILITY_HH │ │ │ │ │ -_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 │ │ │ │ │ +232#endif // DUNE_TYPETREE_FILTERS_HH │ │ │ │ │ +_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 │ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_l_e_a_f_C_o_u_n_t │ │ │ │ │ -auto leafCount(const Tree &tree) │ │ │ │ │ -The number of leaf nodes in the Tree. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:532 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_n_o_d_e_C_o_u_n_t │ │ │ │ │ -auto nodeCount(const Tree &tree) │ │ │ │ │ -The total number of nodes in the Tree. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:524 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_d_e_p_t_h │ │ │ │ │ -auto depth(const Tree &tree) │ │ │ │ │ -The depth of the TypeTree. │ │ │ │ │ -DDeeffiinniittiioonn visitor.hh:508 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e_T_a_g │ │ │ │ │ -Tag designating a leaf node. │ │ │ │ │ -DDeeffiinniittiioonn nodetags.hh:18 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_I_n_f_o │ │ │ │ │ -Struct for obtaining some basic structural information about a TypeTree. │ │ │ │ │ -DDeeffiinniittiioonn utility.hh:121 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_I_n_f_o_:_:_l_e_a_f_C_o_u_n_t │ │ │ │ │ -static const std::size_t leafCount │ │ │ │ │ -The number of leaf nodes in the TypeTree. │ │ │ │ │ -DDeeffiinniittiioonn utility.hh:136 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_I_n_f_o_:_:_d_e_p_t_h │ │ │ │ │ -static const std::size_t depth │ │ │ │ │ -The depth of the TypeTree. │ │ │ │ │ -DDeeffiinniittiioonn utility.hh:130 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_I_n_f_o_:_:_n_o_d_e_C_o_u_n_t │ │ │ │ │ -static const std::size_t nodeCount │ │ │ │ │ -The total number of nodes in the TypeTree. │ │ │ │ │ -DDeeffiinniittiioonn utility.hh:133 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_E_n_t_r_y │ │ │ │ │ +A filter entry describing the mapping of one child in the filtered node. │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:24 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_R_e_s_u_l_t │ │ │ │ │ +The result of a filter. │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:40 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_R_e_s_u_l_t_:_:_I_n_d_e_x_M_a_p │ │ │ │ │ +std::tuple< FilterEntries... > IndexMap │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:44 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_R_e_s_u_l_t_:_:_s_i_z_e │ │ │ │ │ +static const std::size_t size │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:42 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_R_e_s_u_l_t_:_:_a_p_p_l_y │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:48 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_R_e_s_u_l_t_:_:_a_p_p_l_y_:_:_C_h_i_l_d_r_e_n │ │ │ │ │ +std::tuple< typename Node::template Child< FilterEntries::original_index >... > │ │ │ │ │ +Children │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:49 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_R_e_s_u_l_t_:_:_a_p_p_l_y_:_:_C_h_i_l_d_T_y_p_e_s │ │ │ │ │ +std::tuple< typename Node::template Child< FilterEntries::original_index >:: │ │ │ │ │ +Type... > ChildTypes │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:50 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_R_e_s_u_l_t_:_:_a_p_p_l_y_:_:_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ +std::tuple< std::shared_ptr< typename Node::template Child< FilterEntries:: │ │ │ │ │ +original_index >::Type >... > NodeStorage │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:51 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r_T_a_g │ │ │ │ │ +Tag describing a simple filter that can only decide whether or not to include a │ │ │ │ │ +single given child. │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:57 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_d_v_a_n_c_e_d_F_i_l_t_e_r_T_a_g │ │ │ │ │ +Tag describing an advanced filter that has full control over the construction │ │ │ │ │ +of the list of FilterEn... │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:60 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_d_v_a_n_c_e_d_F_i_l_t_e_r │ │ │ │ │ +Base class for advanced filters. │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:65 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_d_v_a_n_c_e_d_F_i_l_t_e_r_:_:_F_i_l_t_e_r_T_a_g │ │ │ │ │ +AdvancedFilterTag FilterTag │ │ │ │ │ +Filter tag for deciding on filter application mechanism. │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:68 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_d_v_a_n_c_e_d_F_i_l_t_e_r_:_:_a_p_p_l_y │ │ │ │ │ +Apply this filter to the given node and children. │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:75 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_d_v_a_n_c_e_d_F_i_l_t_e_r_:_:_a_p_p_l_y_:_:_t_y_p_e │ │ │ │ │ +implementation defined type │ │ │ │ │ +The result of the filtering process. │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:80 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r │ │ │ │ │ +Default simple filter that accepts any node and leaves its child structure │ │ │ │ │ +unchanged. │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:94 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r_:_:_F_i_l_t_e_r_T_a_g │ │ │ │ │ +SimpleFilterTag FilterTag │ │ │ │ │ +Filter tag for deciding on filter application mechanism. │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:97 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r_:_:_v_a_l_i_d_a_t_e │ │ │ │ │ +Validates the combination of filter and node. │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:103 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r_:_:_v_a_l_i_d_a_t_e_:_:_v_a_l_u_e │ │ │ │ │ +static const bool value │ │ │ │ │ +True if the combination of filter and node is valid. │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:105 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r_:_:_a_p_p_l_y │ │ │ │ │ +Applies the filter to the given child node. │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:119 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r_:_:_a_p_p_l_y_:_:_v_a_l_u_e │ │ │ │ │ +static const bool value │ │ │ │ │ +True if the child will be included in the filtered node. │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:121 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_I_n_d_e_x_F_i_l_t_e_r │ │ │ │ │ +Filter class for FilteredCompositeNode that selects the children with the given │ │ │ │ │ +indices. │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:161 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_i_l_t_e_r │ │ │ │ │ +Adapter class that takes a SimpleFilter, validated it and turns it into an │ │ │ │ │ +AdvancedFilter. │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:212 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_i_l_t_e_r_:_:_a_p_p_l_y │ │ │ │ │ +Apply the filter. │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:217 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_i_l_t_e_r_:_:_a_p_p_l_y_:_:_t_y_p_e │ │ │ │ │ +filter_helper< Filter, 0, 0, Children... >::template apply ::type type │ │ │ │ │ +DDeeffiinniittiioonn filters.hh:221 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00050.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: transformationutilities.hh File Reference │ │ │ │ +dune-typetree: nodetags.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -69,21 +69,45 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ -
    transformationutilities.hh File Reference
    │ │ │ │ +
    │ │ │ │ +Classes | │ │ │ │ +Namespaces
    │ │ │ │ +
    nodetags.hh File Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │ -
    #include <dune/typetree/simpletransformationdescriptors.hh>
    │ │ │ │ -#include <dune/typetree/generictransformationdescriptors.hh>
    │ │ │ │ -
    │ │ │ │ + │ │ │ │

    Go to the source code of this file.

    │ │ │ │ +

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +

    │ │ │ │ +Classes

    struct  Dune::TypeTree::LeafNodeTag
     Tag designating a leaf node. More...
     
    struct  Dune::TypeTree::PowerNodeTag
     Tag designating a power node. More...
     
    struct  Dune::TypeTree::DynamicPowerNodeTag
     Tag designating a power node with runtime degree. More...
     
    struct  Dune::TypeTree::CompositeNodeTag
     Tag designating a composite node. More...
     
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +

    │ │ │ │ +Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,12 +1,29 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -transformationutilities.hh File Reference │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_s_i_m_p_l_e_t_r_a_n_s_f_o_r_m_a_t_i_o_n_d_e_s_c_r_i_p_t_o_r_s_._h_h> │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_g_e_n_e_r_i_c_t_r_a_n_s_f_o_r_m_a_t_i_o_n_d_e_s_c_r_i_p_t_o_r_s_._h_h> │ │ │ │ │ +_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s │ │ │ │ │ +nodetags.hh File Reference │ │ │ │ │ _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_:_:_L_e_a_f_N_o_d_e_T_a_g │ │ │ │ │ +  Tag designating a leaf node. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_T_a_g │ │ │ │ │ +  Tag designating a power node. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g │ │ │ │ │ +  Tag designating a power node with runtime degree. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g │ │ │ │ │ +  Tag designating a composite node. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +NNaammeessppaacceess │ │ │ │ │ +namespace   _D_u_n_e │ │ │ │ │ +  │ │ │ │ │ +namespace   _D_u_n_e_:_:_T_y_p_e_T_r_e_e │ │ │ │ │ +  │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00050_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: transformationutilities.hh Source File │ │ │ │ +dune-typetree: nodetags.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,31 +74,54 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -
    transformationutilities.hh
    │ │ │ │ +
    nodetags.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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_TRANSFORMATIONUTILITIES_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_TRANSFORMATIONUTILITIES_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_NODETAGS_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_NODETAGS_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <dune/typetree/simpletransformationdescriptors.hh>
    │ │ │ │ -
    10#include <dune/typetree/generictransformationdescriptors.hh>
    │ │ │ │ +
    9namespace Dune {
    │ │ │ │ +
    10 namespace TypeTree {
    │ │ │ │
    11
    │ │ │ │ -
    12#endif // DUNE_TYPETREE_TRANSFORMATIONUTILITIES_HH
    │ │ │ │ - │ │ │ │ - │ │ │ │ +
    18 struct LeafNodeTag {};
    │ │ │ │ +
    19
    │ │ │ │ +
    21 struct PowerNodeTag {};
    │ │ │ │ +
    22
    │ │ │ │ +
    24 struct DynamicPowerNodeTag {};
    │ │ │ │ +
    25
    │ │ │ │ +
    27 struct CompositeNodeTag {};
    │ │ │ │ +
    28
    │ │ │ │ +
    29#ifndef DOXYGEN
    │ │ │ │ +
    30
    │ │ │ │ +
    32 struct StartTag {};
    │ │ │ │ +
    33
    │ │ │ │ +
    34
    │ │ │ │ +
    35
    │ │ │ │ +
    36#endif // DOXYGEN
    │ │ │ │ +
    37
    │ │ │ │ +
    39
    │ │ │ │ +
    40 } // namespace TypeTree
    │ │ │ │ +
    41} //namespace Dune
    │ │ │ │ +
    42
    │ │ │ │ +
    43#endif // DUNE_TYPETREE_NODETAGS_HH
    │ │ │ │ +
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ +
    Dune::TypeTree::LeafNodeTag
    Tag designating a leaf node.
    Definition nodetags.hh:18
    │ │ │ │ +
    Dune::TypeTree::PowerNodeTag
    Tag designating a power node.
    Definition nodetags.hh:21
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNodeTag
    Tag designating a power node with runtime degree.
    Definition nodetags.hh:24
    │ │ │ │ +
    Dune::TypeTree::CompositeNodeTag
    Tag designating a composite node.
    Definition nodetags.hh:27
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,26 +1,58 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -transformationutilities.hh │ │ │ │ │ +nodetags.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_TRANSFORMATIONUTILITIES_HH │ │ │ │ │ -7#define DUNE_TYPETREE_TRANSFORMATIONUTILITIES_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_NODETAGS_HH │ │ │ │ │ +7#define DUNE_TYPETREE_NODETAGS_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_s_i_m_p_l_e_t_r_a_n_s_f_o_r_m_a_t_i_o_n_d_e_s_c_r_i_p_t_o_r_s_._h_h> │ │ │ │ │ -10#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_g_e_n_e_r_i_c_t_r_a_n_s_f_o_r_m_a_t_i_o_n_d_e_s_c_r_i_p_t_o_r_s_._h_h> │ │ │ │ │ +9namespace _D_u_n_e { │ │ │ │ │ +10 namespace TypeTree { │ │ │ │ │ 11 │ │ │ │ │ -12#endif // DUNE_TYPETREE_TRANSFORMATIONUTILITIES_HH │ │ │ │ │ -_s_i_m_p_l_e_t_r_a_n_s_f_o_r_m_a_t_i_o_n_d_e_s_c_r_i_p_t_o_r_s_._h_h │ │ │ │ │ -_g_e_n_e_r_i_c_t_r_a_n_s_f_o_r_m_a_t_i_o_n_d_e_s_c_r_i_p_t_o_r_s_._h_h │ │ │ │ │ +_1_8 struct _L_e_a_f_N_o_d_e_T_a_g {}; │ │ │ │ │ +19 │ │ │ │ │ +_2_1 struct _P_o_w_e_r_N_o_d_e_T_a_g {}; │ │ │ │ │ +22 │ │ │ │ │ +_2_4 struct _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g {}; │ │ │ │ │ +25 │ │ │ │ │ +_2_7 struct _C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g {}; │ │ │ │ │ +28 │ │ │ │ │ +29#ifndef DOXYGEN │ │ │ │ │ +30 │ │ │ │ │ +32 struct StartTag {}; │ │ │ │ │ +33 │ │ │ │ │ +34 │ │ │ │ │ +35 │ │ │ │ │ +36#endif // DOXYGEN │ │ │ │ │ +37 │ │ │ │ │ +39 │ │ │ │ │ +40 } // namespace TypeTree │ │ │ │ │ +41} //namespace Dune │ │ │ │ │ +42 │ │ │ │ │ +43#endif // DUNE_TYPETREE_NODETAGS_HH │ │ │ │ │ +_D_u_n_e │ │ │ │ │ +DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e_T_a_g │ │ │ │ │ +Tag designating a leaf node. │ │ │ │ │ +DDeeffiinniittiioonn nodetags.hh:18 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_T_a_g │ │ │ │ │ +Tag designating a power node. │ │ │ │ │ +DDeeffiinniittiioonn nodetags.hh:21 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g │ │ │ │ │ +Tag designating a power node with runtime degree. │ │ │ │ │ +DDeeffiinniittiioonn nodetags.hh:24 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g │ │ │ │ │ +Tag designating a composite node. │ │ │ │ │ +DDeeffiinniittiioonn nodetags.hh:27 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00053.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: childextraction.hh File Reference │ │ │ │ +dune-typetree: nodeinterface.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -70,66 +70,61 @@ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    │ │ │ │ +Classes | │ │ │ │ Namespaces | │ │ │ │ Typedefs | │ │ │ │ Functions
    │ │ │ │ -
    childextraction.hh File Reference
    │ │ │ │ +
    nodeinterface.hh File Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │ -
    #include <type_traits>
    │ │ │ │ -#include <utility>
    │ │ │ │ -#include <dune/common/concept.hh>
    │ │ │ │ +
    #include <cstddef>
    │ │ │ │ +#include <type_traits>
    │ │ │ │ #include <dune/common/documentation.hh>
    │ │ │ │ -#include <dune/common/typetraits.hh>
    │ │ │ │ -#include <dune/common/shared_ptr.hh>
    │ │ │ │ -#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ -#include <dune/typetree/treepath.hh>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │ │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +

    │ │ │ │ +Classes

    struct  Dune::TypeTree::NodeInterface
     Interface for nodes in a dune-typetree. More...
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
     
    │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │

    │ │ │ │ Typedefs

    template<typename Node , std::size_t... indices>
    using Dune::TypeTree::Child = typename impl::_Child< Node, indices... >::type
     Template alias for the type of a child node given by a list of child indices.
     
    template<typename Node , typename TreePath >
    using Dune::TypeTree::ChildForTreePath = typename impl::_ChildForTreePath< Node, TreePath >::type
     Template alias for the type of a child node given by a TreePath or a HybridTreePath type.
     
    template<typename T >
    using Dune::TypeTree::is_flat_index = typename impl::_is_flat_index< std::decay_t< T > >::type
     Type trait that determines whether T is a flat index in the context of child extraction.
     
    template<typename Node >
    using Dune::TypeTree::NodeTag = typename std::decay_t< Node >::NodeTag
     Returns the node tag of the given Node.
     
    template<typename T >
    using Dune::TypeTree::ImplementationTag = typename std::decay_t< T >::ImplementationTag
     Returns the implementation tag of the given Node.
     
    template<typename Node >
    using Dune::TypeTree::StaticDegree = decltype(Node::degree())
     Returns the statically known degree of the given Node type as a std::integral_constant.
     
    │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │

    │ │ │ │ Functions

    template<typename Node , typename... Indices>
    ImplementationDefined Dune::TypeTree::child (Node &&node, Indices... indices)
     Extracts the child of a node given by a sequence of compile-time and run-time indices.
     
    template<typename Node , typename... Indices>
    ImplementationDefined Dune::TypeTree::childStorage (Node &&node, Indices... indices)
     
    template<typename Node , typename... Indices>
    ImplementationDefined Dune::TypeTree::child (Node &&node, HybridTreePath< Indices... > treePath)
     Extracts the child of a node given by a HybridTreePath object.
     
    template<typename Node >
    std::size_t Dune::TypeTree::degree (const Node &node)
     Returns the degree of node as run time information.
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,58 +1,43 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -_N_a_m_e_s_p_a_c_e_s | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s │ │ │ │ │ -childextraction.hh File Reference │ │ │ │ │ +_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s │ │ │ │ │ +nodeinterface.hh File Reference │ │ │ │ │ +#include │ │ │ │ │ #include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ #include │ │ │ │ │ -#include │ │ │ │ │ -#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_/_t_r_e_e_p_a_t_h_._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_:_:_N_o_d_e_I_n_t_e_r_f_a_c_e │ │ │ │ │ +  Interface for nodes in a _d_u_n_e_-_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 │ │ │ │ │   │ │ │ │ │ TTyyppeeddeeffss │ │ │ │ │ -template │ │ │ │ │ -using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_h_i_l_d = typename impl::_Child< Node, indices... >::type │ │ │ │ │ -  Template alias for the type of a child node given by a list of child │ │ │ │ │ - indices. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ -using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_h_i_l_d_F_o_r_T_r_e_e_P_a_t_h = typename impl::_ChildForTreePath< │ │ │ │ │ - Node, TreePath >::type │ │ │ │ │ -  Template alias for the type of a child node given by a TreePath or a │ │ │ │ │ - _H_y_b_r_i_d_T_r_e_e_P_a_t_h type. │ │ │ │ │ +template │ │ │ │ │ +using  _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 │ │ │ │ │ +  Returns the node tag of the given Node. │ │ │ │ │   │ │ │ │ │ template │ │ │ │ │ -using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_s___f_l_a_t___i_n_d_e_x = typename impl::_is_flat_index< std:: │ │ │ │ │ - decay_t< T > >::type │ │ │ │ │ -  Type trait that determines whether T is a flat index in the context of │ │ │ │ │ - child extraction. │ │ │ │ │ +using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_I_m_p_l_e_m_e_n_t_a_t_i_o_n_T_a_g = typename std::decay_t< T >:: │ │ │ │ │ + ImplementationTag │ │ │ │ │ +  Returns the implementation tag of the given Node. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ +using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_D_e_g_r_e_e = decltype(Node::degree()) │ │ │ │ │ +  Returns the statically known degree of the given Node type as a std:: │ │ │ │ │ + integral_constant. │ │ │ │ │   │ │ │ │ │ FFuunnccttiioonnss │ │ │ │ │ -template │ │ │ │ │ -ImplementationDefined  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_c_h_i_l_d (Node &&node, Indices... indices) │ │ │ │ │ -  Extracts the child of a node given by a sequence of │ │ │ │ │ - compile-time and run-time indices. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ -ImplementationDefined  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e (Node &&node, Indices... │ │ │ │ │ - indices) │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ -ImplementationDefined  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_c_h_i_l_d (Node &&node, _H_y_b_r_i_d_T_r_e_e_P_a_t_h< │ │ │ │ │ - Indices... > _t_r_e_e_P_a_t_h) │ │ │ │ │ -  Extracts the child of a node given by a _H_y_b_r_i_d_T_r_e_e_P_a_t_h │ │ │ │ │ - object. │ │ │ │ │ +template │ │ │ │ │ +std::size_t  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_d_e_g_r_e_e (const Node &node) │ │ │ │ │ +  Returns the degree of node as run time information. │ │ │ │ │   │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00053_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: childextraction.hh Source File │ │ │ │ +dune-typetree: nodeinterface.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,290 +74,100 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -
    childextraction.hh
    │ │ │ │ +
    nodeinterface.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    1// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
    │ │ │ │
    2// vi: set et ts=8 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_CHILDEXTRACTION_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_CHILDEXTRACTION_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_NODEINTERFACE_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_NODEINTERFACE_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <type_traits>
    │ │ │ │ -
    10#include <utility>
    │ │ │ │ +
    9#include <cstddef>
    │ │ │ │ +
    10#include <type_traits>
    │ │ │ │
    11
    │ │ │ │ -
    12#include <dune/common/concept.hh>
    │ │ │ │ -
    13#include <dune/common/documentation.hh>
    │ │ │ │ -
    14#include <dune/common/typetraits.hh>
    │ │ │ │ -
    15#include <dune/common/shared_ptr.hh>
    │ │ │ │ +
    12#include <dune/common/documentation.hh>
    │ │ │ │ +
    13
    │ │ │ │ +
    14namespace Dune {
    │ │ │ │ +
    15 namespace TypeTree {
    │ │ │ │
    16
    │ │ │ │ -
    17#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ -
    18#include <dune/typetree/treepath.hh>
    │ │ │ │ -
    19
    │ │ │ │ -
    20
    │ │ │ │ -
    21namespace Dune {
    │ │ │ │ -
    22 namespace TypeTree {
    │ │ │ │ -
    23
    │ │ │ │ -
    28
    │ │ │ │ -
    29#ifndef DOXYGEN
    │ │ │ │ -
    30
    │ │ │ │ -
    31 namespace Impl {
    │ │ │ │ -
    32
    │ │ │ │ -
    33 // check at run time whether index is a valid child index
    │ │ │ │ -
    34 template <class Node, class Index>
    │ │ │ │ -
    35 std::true_type checkChildIndex (Node const& node, Index i)
    │ │ │ │ -
    36 {
    │ │ │ │ -
    37 assert(std::size_t(i) < node.degree() && "Child index out of range");
    │ │ │ │ -
    38 return {};
    │ │ │ │ -
    39 }
    │ │ │ │ -
    40
    │ │ │ │ -
    41 // check at compile time whether index is a valid index
    │ │ │ │ -
    42 template <class Node, std::size_t i>
    │ │ │ │ -
    43 std::bool_constant<(i < Node::degree())> checkChildIndex (Node const& node, index_constant<i>)
    │ │ │ │ -
    44 {
    │ │ │ │ -
    45 static_assert(i < Node::degree(), "Child index out of range");
    │ │ │ │ -
    46 return {};
    │ │ │ │ -
    47 }
    │ │ │ │ -
    48
    │ │ │ │ -
    49 // finally return the node itself if no further indices are provided. Break condition
    │ │ │ │ -
    50 // for the recursion over the node childs.
    │ │ │ │ -
    51 template<class Node>
    │ │ │ │ -
    52 decltype(auto) childImpl (Node&& node)
    │ │ │ │ -
    53 {
    │ │ │ │ -
    54 return std::forward<Node>(node);
    │ │ │ │ -
    55 }
    │ │ │ │ -
    56
    │ │ │ │ -
    57 template<class NodePtr>
    │ │ │ │ -
    58 auto childStorageImpl (NodePtr&& nodePtr)
    │ │ │ │ -
    59 {
    │ │ │ │ -
    60 return std::forward<NodePtr>(nodePtr);
    │ │ │ │ -
    61 }
    │ │ │ │ +
    │ │ │ │ +
    34 struct NodeInterface
    │ │ │ │ +
    35 {
    │ │ │ │ +
    37 static const bool isLeaf = implementationDefined;
    │ │ │ │ +
    38
    │ │ │ │ +
    40 static const bool isPower = implementationDefined;
    │ │ │ │ +
    41
    │ │ │ │ +
    43 static const bool isComposite = implementationDefined;
    │ │ │ │ +
    44
    │ │ │ │ +
    46
    │ │ │ │ +
    51 static auto degree();
    │ │ │ │ +
    52
    │ │ │ │ +
    54
    │ │ │ │ +
    59 typedef ImplementationDefined NodeTag;
    │ │ │ │ +
    60
    │ │ │ │
    62
    │ │ │ │ -
    63 // recursively call `node.child(...)` with the given indices
    │ │ │ │ -
    64 template<class Node, class I0, class... I>
    │ │ │ │ -
    65 decltype(auto) childImpl (Node&& node, I0 i0, [[maybe_unused]] I... i)
    │ │ │ │ -
    66 {
    │ │ │ │ -
    67 auto valid = checkChildIndex(node,i0);
    │ │ │ │ -
    68 if constexpr (valid)
    │ │ │ │ -
    69 return childImpl(node.child(i0),i...);
    │ │ │ │ -
    70 else
    │ │ │ │ -
    71 return;
    │ │ │ │ -
    72 }
    │ │ │ │ -
    73
    │ │ │ │ -
    74 // recursively call `node.childStorage(...)` with the given indices
    │ │ │ │ -
    75 template<class NodePtr, class I0, class... I>
    │ │ │ │ -
    76 decltype(auto) childStorageImpl (NodePtr&& nodePtr, I0 i0, [[maybe_unused]] I... i)
    │ │ │ │ -
    77 {
    │ │ │ │ -
    78 auto valid = checkChildIndex(*nodePtr,i0);
    │ │ │ │ -
    79 if constexpr (valid)
    │ │ │ │ -
    80 return childStorageImpl(nodePtr->childStorage(i0),i...);
    │ │ │ │ -
    81 else
    │ │ │ │ -
    82 return;
    │ │ │ │ -
    83 }
    │ │ │ │ -
    84
    │ │ │ │ -
    85 // forward to the impl methods by extracting the indices from the treepath
    │ │ │ │ -
    86 template<class Node, class... Indices, std::size_t... i>
    │ │ │ │ -
    87 decltype(auto) child (Node&& node, [[maybe_unused]] HybridTreePath<Indices...> tp, std::index_sequence<i...>)
    │ │ │ │ -
    88 {
    │ │ │ │ -
    89 return childImpl(std::forward<Node>(node),treePathEntry<i>(tp)...);
    │ │ │ │ -
    90 }
    │ │ │ │ -
    91
    │ │ │ │ -
    92 // forward to the impl methods by extracting the indices from the treepath
    │ │ │ │ -
    93 template<class NodePtr, class... Indices, std::size_t... i>
    │ │ │ │ -
    94 decltype(auto) childStorage (NodePtr&& nodePtr, [[maybe_unused]] HybridTreePath<Indices...> tp, std::index_sequence<i...>)
    │ │ │ │ -
    95 {
    │ │ │ │ -
    96 return childStorageImpl(std::forward<NodePtr>(nodePtr),treePathEntry<i>(tp)...);
    │ │ │ │ -
    97 }
    │ │ │ │ +
    65 typedef ImplementationDefined NodeStorage;
    │ │ │ │ +
    66 };
    │ │ │ │ +
    │ │ │ │ +
    67
    │ │ │ │ +
    69 template<typename Node>
    │ │ │ │ +
    70 using NodeTag = typename std::decay_t<Node>::NodeTag;
    │ │ │ │ +
    71
    │ │ │ │ +
    73 template<typename T>
    │ │ │ │ +
    74 using ImplementationTag = typename std::decay_t<T>::ImplementationTag;
    │ │ │ │ +
    75
    │ │ │ │ +
    76
    │ │ │ │ +
    78 template<typename Node>
    │ │ │ │ +
    │ │ │ │ +
    79 std::size_t degree(const Node& node)
    │ │ │ │ +
    80 {
    │ │ │ │ +
    81 return degree(&node,NodeTag<Node>());
    │ │ │ │ +
    82 }
    │ │ │ │ +
    │ │ │ │ +
    83
    │ │ │ │ +
    84#ifndef DOXYGEN
    │ │ │ │ +
    85
    │ │ │ │ +
    87
    │ │ │ │ +
    93 template<typename Node, typename NodeTag>
    │ │ │ │ +
    94 std::size_t degree(const Node* node, NodeTag)
    │ │ │ │ +
    95 {
    │ │ │ │ +
    96 return node->degree();
    │ │ │ │ +
    97 }
    │ │ │ │
    98
    │ │ │ │ -
    99 } // end namespace Impl
    │ │ │ │ +
    99#endif // DOXYGEN
    │ │ │ │
    100
    │ │ │ │ -
    101#endif // DOXYGEN
    │ │ │ │
    102
    │ │ │ │ -
    104
    │ │ │ │ -
    126 template<typename Node, typename... Indices>
    │ │ │ │ -
    127#ifdef DOXYGEN
    │ │ │ │ -
    │ │ │ │ -
    128 ImplementationDefined child (Node&& node, Indices... indices)
    │ │ │ │ -
    129#else
    │ │ │ │ -
    130 decltype(auto) child (Node&& node, Indices... indices)
    │ │ │ │ -
    131#endif
    │ │ │ │ -
    132 {
    │ │ │ │ -
    133 return Impl::childImpl(std::forward<Node>(node),indices...);
    │ │ │ │ -
    134 }
    │ │ │ │ -
    │ │ │ │ -
    135
    │ │ │ │ -
    136 template<typename Node, typename... Indices>
    │ │ │ │ -
    137#ifdef DOXYGEN
    │ │ │ │ -
    │ │ │ │ -
    138 ImplementationDefined childStorage (Node&& node, Indices... indices)
    │ │ │ │ -
    139#else
    │ │ │ │ -
    140 auto childStorage (Node&& node, Indices... indices)
    │ │ │ │ -
    141#endif
    │ │ │ │ -
    142 {
    │ │ │ │ -
    143 static_assert(sizeof...(Indices) > 0, "childStorage() cannot be called with an empty list of child indices");
    │ │ │ │ -
    144 return Impl::childStorageImpl(&node,indices...);
    │ │ │ │ -
    145 }
    │ │ │ │ -
    │ │ │ │ -
    146
    │ │ │ │ -
    148
    │ │ │ │ -
    171 template<typename Node, typename... Indices>
    │ │ │ │ -
    172#ifdef DOXYGEN
    │ │ │ │ -
    │ │ │ │ -
    173 ImplementationDefined child (Node&& node, HybridTreePath<Indices...> treePath)
    │ │ │ │ -
    174#else
    │ │ │ │ -
    175 decltype(auto) child (Node&& node, HybridTreePath<Indices...> tp)
    │ │ │ │ -
    176#endif
    │ │ │ │ -
    177 {
    │ │ │ │ -
    178 return Impl::child(std::forward<Node>(node),tp,std::index_sequence_for<Indices...>{});
    │ │ │ │ -
    179 }
    │ │ │ │ -
    │ │ │ │ -
    180
    │ │ │ │ -
    181 template<typename Node, typename... Indices>
    │ │ │ │ -
    182#ifdef DOXYGEN
    │ │ │ │ -
    183 ImplementationDefined child (Node&& node, HybridTreePath<Indices...> treePath)
    │ │ │ │ -
    184#else
    │ │ │ │ -
    185 auto childStorage (Node&& node, HybridTreePath<Indices...> tp)
    │ │ │ │ -
    186#endif
    │ │ │ │ -
    187 {
    │ │ │ │ -
    188 static_assert(sizeof...(Indices) > 0, "childStorage() cannot be called with an empty TreePath");
    │ │ │ │ -
    189 return Impl::childStorage(&node,tp,std::index_sequence_for<Indices...>{});
    │ │ │ │ -
    190 }
    │ │ │ │ -
    191
    │ │ │ │ -
    192
    │ │ │ │ -
    193#ifndef DOXYGEN
    │ │ │ │ -
    194
    │ │ │ │ -
    195 namespace impl {
    │ │ │ │ -
    196
    │ │ │ │ -
    197 template<typename T>
    │ │ │ │ -
    198 struct filter_void
    │ │ │ │ -
    199 {
    │ │ │ │ -
    200 using type = T;
    │ │ │ │ -
    201 };
    │ │ │ │ -
    202
    │ │ │ │ -
    203 template<>
    │ │ │ │ -
    204 struct filter_void<void>
    │ │ │ │ -
    205 {};
    │ │ │ │ -
    206
    │ │ │ │ -
    207 template<typename Node, std::size_t... indices>
    │ │ │ │ -
    208 struct _Child
    │ │ │ │ -
    209 : public filter_void<std::decay_t<decltype(child(std::declval<Node>(),index_constant<indices>{}...))>>
    │ │ │ │ -
    210 {};
    │ │ │ │ -
    211
    │ │ │ │ -
    212 }
    │ │ │ │ -
    213
    │ │ │ │ -
    214#endif // DOXYGEN
    │ │ │ │ -
    215
    │ │ │ │ -
    217
    │ │ │ │ -
    224 template<typename Node, std::size_t... indices>
    │ │ │ │ -
    225 using Child = typename impl::_Child<Node,indices...>::type;
    │ │ │ │ -
    226
    │ │ │ │ -
    227
    │ │ │ │ -
    228#ifndef DOXYGEN
    │ │ │ │ -
    229
    │ │ │ │ -
    230 namespace impl {
    │ │ │ │ -
    231
    │ │ │ │ -
    232 template<typename Node, typename TreePath>
    │ │ │ │ -
    233 struct _ChildForTreePath
    │ │ │ │ -
    234 {
    │ │ │ │ -
    235 using type = typename std::decay<decltype(child(std::declval<Node>(),std::declval<TreePath>()))>::type;
    │ │ │ │ -
    236 };
    │ │ │ │ -
    237
    │ │ │ │ -
    238 }
    │ │ │ │ -
    239
    │ │ │ │ -
    240#endif // DOXYGEN
    │ │ │ │ -
    241
    │ │ │ │ -
    243
    │ │ │ │ -
    251 template<typename Node, typename TreePath>
    │ │ │ │ -
    252 using ChildForTreePath = typename impl::_ChildForTreePath<Node,TreePath>::type;
    │ │ │ │ -
    253
    │ │ │ │ -
    254
    │ │ │ │ -
    255#ifndef DOXYGEN
    │ │ │ │ -
    256
    │ │ │ │ -
    257 namespace impl {
    │ │ │ │ -
    258
    │ │ │ │ -
    259 // By default, types are flat indices if they are integral
    │ │ │ │ -
    260 template<typename T>
    │ │ │ │ -
    261 struct _is_flat_index
    │ │ │ │ -
    262 {
    │ │ │ │ -
    263 using type = std::is_integral<T>;
    │ │ │ │ -
    264 };
    │ │ │ │ -
    265
    │ │ │ │ -
    266 // And so is any index_constant
    │ │ │ │ -
    267 template<std::size_t i>
    │ │ │ │ -
    268 struct _is_flat_index<index_constant<i>>
    │ │ │ │ -
    269 {
    │ │ │ │ -
    270 using type = std::true_type;
    │ │ │ │ -
    271 };
    │ │ │ │ -
    272
    │ │ │ │ -
    273 }
    │ │ │ │ -
    274
    │ │ │ │ -
    275#endif // DOXYGEN
    │ │ │ │ -
    276
    │ │ │ │ -
    278 /*
    │ │ │ │ -
    279 * This type trait can be used to check whether T is a flat index (i.e. either `std::size_t`
    │ │ │ │ -
    280 * or `index_constant`). The type trait normalizes T before doing the check, so it will also
    │ │ │ │ -
    281 * work correctly for references and cv-qualified types.
    │ │ │ │ -
    282 */
    │ │ │ │ -
    283 template<typename T>
    │ │ │ │ -
    284 using is_flat_index = typename impl::_is_flat_index<std::decay_t<T>>::type;
    │ │ │ │ -
    285
    │ │ │ │ -
    286#ifndef DOXYGEN
    │ │ │ │ -
    287
    │ │ │ │ -
    288 namespace impl {
    │ │ │ │ -
    289
    │ │ │ │ -
    290 // helper function for check in member child() functions that tolerates being passed something that
    │ │ │ │ -
    291 // isn't a TreePath. It will just return 0 in that case
    │ │ │ │ -
    292
    │ │ │ │ -
    293 template<typename T>
    │ │ │ │ -
    294 constexpr typename std::enable_if<
    │ │ │ │ -
    295 Dune::TypeTree::is_flat_index<T>::value,
    │ │ │ │ -
    296 bool
    │ │ │ │ -
    297 >::type
    │ │ │ │ -
    298 _non_empty_tree_path (T)
    │ │ │ │ -
    299 {
    │ │ │ │ -
    300 return false;
    │ │ │ │ -
    301 }
    │ │ │ │ -
    302
    │ │ │ │ -
    303 template<typename T>
    │ │ │ │ -
    304 constexpr typename std::enable_if<
    │ │ │ │ -
    305 !Dune::TypeTree::is_flat_index<T>::value,
    │ │ │ │ -
    306 bool
    │ │ │ │ -
    307 >::type
    │ │ │ │ -
    308 _non_empty_tree_path (T t)
    │ │ │ │ -
    309 {
    │ │ │ │ -
    310 return treePathSize(t) > 0;
    │ │ │ │ -
    311 }
    │ │ │ │ -
    312
    │ │ │ │ -
    313 }
    │ │ │ │ -
    314
    │ │ │ │ -
    315#endif // DOXYGEN
    │ │ │ │ -
    316
    │ │ │ │ -
    318
    │ │ │ │ -
    319 } // namespace TypeTree
    │ │ │ │ -
    320} //namespace Dune
    │ │ │ │ -
    321
    │ │ │ │ -
    322#endif // DUNE_TYPETREE_CHILDEXTRACTION_HH
    │ │ │ │ - │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::is_flat_index
    typename impl::_is_flat_index< std::decay_t< T > >::type is_flat_index
    Type trait that determines whether T is a flat index in the context of child extraction.
    Definition childextraction.hh:284
    │ │ │ │ -
    Dune::TypeTree::childStorage
    ImplementationDefined childStorage(Node &&node, Indices... indices)
    Definition childextraction.hh:138
    │ │ │ │ -
    Dune::TypeTree::Child
    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
    │ │ │ │ -
    Dune::TypeTree::child
    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
    │ │ │ │ -
    Dune::TypeTree::ChildForTreePath
    typename impl::_ChildForTreePath< Node, TreePath >::type ChildForTreePath
    Template alias for the type of a child node given by a TreePath or a HybridTreePath type.
    Definition childextraction.hh:252
    │ │ │ │ -
    Dune::TypeTree::treePathSize
    constexpr std::size_t treePathSize(const HybridTreePath< T... > &)
    Returns the size (number of components) of the given HybridTreePath.
    Definition treepath.hh:334
    │ │ │ │ -
    Dune::TypeTree::treePath
    constexpr auto treePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:326
    │ │ │ │ +
    106 template<typename Node>
    │ │ │ │ +
    107 using StaticDegree = decltype(Node::degree());
    │ │ │ │ +
    108
    │ │ │ │ +
    110
    │ │ │ │ +
    111 } // namespace TypeTree
    │ │ │ │ +
    112} //namespace Dune
    │ │ │ │ +
    113
    │ │ │ │ +
    114#endif // DUNE_TYPETREE_NODEINTERFACE_HH
    │ │ │ │ +
    Dune::TypeTree::degree
    std::size_t degree(const Node &node)
    Returns the degree of node as run time information.
    Definition nodeinterface.hh:79
    │ │ │ │ +
    Dune::TypeTree::NodeTag
    typename std::decay_t< Node >::NodeTag NodeTag
    Returns the node tag of the given Node.
    Definition nodeinterface.hh:70
    │ │ │ │ +
    Dune::TypeTree::ImplementationTag
    typename std::decay_t< T >::ImplementationTag ImplementationTag
    Returns the implementation tag of the given Node.
    Definition nodeinterface.hh:74
    │ │ │ │ +
    Dune::TypeTree::StaticDegree
    decltype(Node::degree()) StaticDegree
    Returns the statically known degree of the given Node type as a std::integral_constant.
    Definition nodeinterface.hh:107
    │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::HybridTreePath
    A hybrid version of TreePath that supports both compile time and run time indices.
    Definition treepath.hh:158
    │ │ │ │ +
    Dune::TypeTree::NodeInterface
    Interface for nodes in a dune-typetree.
    Definition nodeinterface.hh:35
    │ │ │ │ +
    Dune::TypeTree::NodeInterface::degree
    static auto degree()
    Number of children of this node in the dune-typetree.
    │ │ │ │ +
    Dune::TypeTree::NodeInterface::isPower
    static const bool isPower
    Whether this is a power node in the dune-typetree.
    Definition nodeinterface.hh:40
    │ │ │ │ +
    Dune::TypeTree::NodeInterface::isLeaf
    static const bool isLeaf
    Whether this is a leaf node in a dune-typetree.
    Definition nodeinterface.hh:37
    │ │ │ │ +
    Dune::TypeTree::NodeInterface::NodeStorage
    ImplementationDefined NodeStorage
    container type to pass around a collection of children
    Definition nodeinterface.hh:65
    │ │ │ │ +
    Dune::TypeTree::NodeInterface::isComposite
    static const bool isComposite
    Whether this is a composite node in the dune-typetree.
    Definition nodeinterface.hh:43
    │ │ │ │ +
    Dune::TypeTree::NodeInterface::NodeTag
    ImplementationDefined NodeTag
    The type tag that describes what kind of node this is.
    Definition nodeinterface.hh:59
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,323 +1,124 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -childextraction.hh │ │ │ │ │ +nodeinterface.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: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- │ │ │ │ │ 2// vi: set et ts=8 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_CHILDEXTRACTION_HH │ │ │ │ │ -7#define DUNE_TYPETREE_CHILDEXTRACTION_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_NODEINTERFACE_HH │ │ │ │ │ +7#define DUNE_TYPETREE_NODEINTERFACE_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include │ │ │ │ │ -10#include │ │ │ │ │ +9#include │ │ │ │ │ +10#include │ │ │ │ │ 11 │ │ │ │ │ -12#include │ │ │ │ │ -13#include │ │ │ │ │ -14#include │ │ │ │ │ -15#include │ │ │ │ │ +12#include │ │ │ │ │ +13 │ │ │ │ │ +14namespace _D_u_n_e { │ │ │ │ │ +15 namespace TypeTree { │ │ │ │ │ 16 │ │ │ │ │ -17#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> │ │ │ │ │ -18#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_e_e_p_a_t_h_._h_h> │ │ │ │ │ -19 │ │ │ │ │ -20 │ │ │ │ │ -21namespace _D_u_n_e { │ │ │ │ │ -22 namespace TypeTree { │ │ │ │ │ -23 │ │ │ │ │ -28 │ │ │ │ │ -29#ifndef DOXYGEN │ │ │ │ │ -30 │ │ │ │ │ -31 namespace Impl { │ │ │ │ │ -32 │ │ │ │ │ -33 // check at run time whether index is a valid child index │ │ │ │ │ -34 template │ │ │ │ │ -35 std::true_type checkChildIndex (Node const& node, Index i) │ │ │ │ │ -36 { │ │ │ │ │ -37 assert(std::size_t(i) < node.degree() && "Child index out of range"); │ │ │ │ │ -38 return {}; │ │ │ │ │ -39 } │ │ │ │ │ -40 │ │ │ │ │ -41 // check at compile time whether index is a valid index │ │ │ │ │ -42 template │ │ │ │ │ -43 std::bool_constant<(i < Node::degree())> checkChildIndex (Node const& node, │ │ │ │ │ -index_constant) │ │ │ │ │ -44 { │ │ │ │ │ -45 static_assert(i < Node::degree(), "Child index out of range"); │ │ │ │ │ -46 return {}; │ │ │ │ │ -47 } │ │ │ │ │ -48 │ │ │ │ │ -49 // finally return the node itself if no further indices are provided. Break │ │ │ │ │ -condition │ │ │ │ │ -50 // for the recursion over the node childs. │ │ │ │ │ -51 template │ │ │ │ │ -52 decltype(auto) childImpl (Node&& node) │ │ │ │ │ -53 { │ │ │ │ │ -54 return std::forward(node); │ │ │ │ │ -55 } │ │ │ │ │ -56 │ │ │ │ │ -57 template │ │ │ │ │ -58 auto childStorageImpl (NodePtr&& nodePtr) │ │ │ │ │ -59 { │ │ │ │ │ -60 return std::forward(nodePtr); │ │ │ │ │ -61 } │ │ │ │ │ +_3_4 struct _N_o_d_e_I_n_t_e_r_f_a_c_e │ │ │ │ │ +35 { │ │ │ │ │ +_3_7 static const bool _i_s_L_e_a_f = implementationDefined; │ │ │ │ │ +38 │ │ │ │ │ +_4_0 static const bool _i_s_P_o_w_e_r = implementationDefined; │ │ │ │ │ +41 │ │ │ │ │ +_4_3 static const bool _i_s_C_o_m_p_o_s_i_t_e = implementationDefined; │ │ │ │ │ +44 │ │ │ │ │ +46 │ │ │ │ │ +_5_1 static auto _d_e_g_r_e_e(); │ │ │ │ │ +52 │ │ │ │ │ +54 │ │ │ │ │ +_5_9 typedef ImplementationDefined _N_o_d_e_T_a_g; │ │ │ │ │ +60 │ │ │ │ │ 62 │ │ │ │ │ -63 // recursively call `node.child(...)` with the given indices │ │ │ │ │ -64 template │ │ │ │ │ -65 decltype(auto) childImpl (Node&& node, I0 i0, [[maybe_unused]] I... i) │ │ │ │ │ -66 { │ │ │ │ │ -67 auto valid = checkChildIndex(node,i0); │ │ │ │ │ -68 if constexpr (valid) │ │ │ │ │ -69 return childImpl(node.child(i0),i...); │ │ │ │ │ -70 else │ │ │ │ │ -71 return; │ │ │ │ │ -72 } │ │ │ │ │ -73 │ │ │ │ │ -74 // recursively call `node.childStorage(...)` with the given indices │ │ │ │ │ -75 template │ │ │ │ │ -76 decltype(auto) childStorageImpl (NodePtr&& nodePtr, I0 i0, [[maybe_unused]] │ │ │ │ │ -I... i) │ │ │ │ │ -77 { │ │ │ │ │ -78 auto valid = checkChildIndex(*nodePtr,i0); │ │ │ │ │ -79 if constexpr (valid) │ │ │ │ │ -80 return childStorageImpl(nodePtr->childStorage(i0),i...); │ │ │ │ │ -81 else │ │ │ │ │ -82 return; │ │ │ │ │ -83 } │ │ │ │ │ -84 │ │ │ │ │ -85 // forward to the impl methods by extracting the indices from the treepath │ │ │ │ │ -86 template │ │ │ │ │ -87 decltype(auto) _c_h_i_l_d (Node&& node, [[maybe_unused]] │ │ │ │ │ -HybridTreePath tp, std::index_sequence) │ │ │ │ │ -88 { │ │ │ │ │ -89 return childImpl(std::forward(node),treePathEntry(tp)...); │ │ │ │ │ -90 } │ │ │ │ │ -91 │ │ │ │ │ -92 // forward to the impl methods by extracting the indices from the treepath │ │ │ │ │ -93 template │ │ │ │ │ -94 decltype(auto) _c_h_i_l_d_S_t_o_r_a_g_e (NodePtr&& nodePtr, [[maybe_unused]] │ │ │ │ │ -HybridTreePath tp, std::index_sequence) │ │ │ │ │ +_6_5 typedef ImplementationDefined _N_o_d_e_S_t_o_r_a_g_e; │ │ │ │ │ +66 }; │ │ │ │ │ +67 │ │ │ │ │ +69 template │ │ │ │ │ +_7_0 using _N_o_d_e_T_a_g = typename std::decay_t::NodeTag; │ │ │ │ │ +71 │ │ │ │ │ +73 template │ │ │ │ │ +_7_4 using _I_m_p_l_e_m_e_n_t_a_t_i_o_n_T_a_g = typename std::decay_t::ImplementationTag; │ │ │ │ │ +75 │ │ │ │ │ +76 │ │ │ │ │ +78 template │ │ │ │ │ +_7_9 std::size_t _d_e_g_r_e_e(const Node& node) │ │ │ │ │ +80 { │ │ │ │ │ +81 return _d_e_g_r_e_e(&node,_N_o_d_e_T_a_g_<_N_o_d_e_>()); │ │ │ │ │ +82 } │ │ │ │ │ +83 │ │ │ │ │ +84#ifndef DOXYGEN │ │ │ │ │ +85 │ │ │ │ │ +87 │ │ │ │ │ +93 template │ │ │ │ │ +94 std::size_t _d_e_g_r_e_e(const Node* node, _N_o_d_e_T_a_g) │ │ │ │ │ 95 { │ │ │ │ │ -96 return childStorageImpl(std::forward(nodePtr),treePathEntry │ │ │ │ │ -(tp)...); │ │ │ │ │ +96 return node->degree(); │ │ │ │ │ 97 } │ │ │ │ │ 98 │ │ │ │ │ -99 } // end namespace Impl │ │ │ │ │ +99#endif // DOXYGEN │ │ │ │ │ 100 │ │ │ │ │ -101#endif // DOXYGEN │ │ │ │ │ 102 │ │ │ │ │ -104 │ │ │ │ │ -126 template │ │ │ │ │ -127#ifdef DOXYGEN │ │ │ │ │ -_1_2_8 ImplementationDefined _c_h_i_l_d (Node&& node, Indices... indices) │ │ │ │ │ -129#else │ │ │ │ │ -130 decltype(auto) _c_h_i_l_d (Node&& node, Indices... indices) │ │ │ │ │ -131#endif │ │ │ │ │ -132 { │ │ │ │ │ -133 return Impl::childImpl(std::forward(node),indices...); │ │ │ │ │ -134 } │ │ │ │ │ -135 │ │ │ │ │ -136 template │ │ │ │ │ -137#ifdef DOXYGEN │ │ │ │ │ -_1_3_8 ImplementationDefined _c_h_i_l_d_S_t_o_r_a_g_e (Node&& node, Indices... indices) │ │ │ │ │ -139#else │ │ │ │ │ -140 auto _c_h_i_l_d_S_t_o_r_a_g_e (Node&& node, Indices... indices) │ │ │ │ │ -141#endif │ │ │ │ │ -142 { │ │ │ │ │ -143 static_assert(sizeof...(Indices) > 0, "childStorage() cannot be called with │ │ │ │ │ -an empty list of child indices"); │ │ │ │ │ -144 return Impl::childStorageImpl(&node,indices...); │ │ │ │ │ -145 } │ │ │ │ │ -146 │ │ │ │ │ -148 │ │ │ │ │ -171 template │ │ │ │ │ -172#ifdef DOXYGEN │ │ │ │ │ -_1_7_3 ImplementationDefined _c_h_i_l_d (Node&& node, _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_I_n_d_i_c_e_s_._._._> │ │ │ │ │ -_t_r_e_e_P_a_t_h) │ │ │ │ │ -174#else │ │ │ │ │ -175 decltype(auto) _c_h_i_l_d (Node&& node, _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_I_n_d_i_c_e_s_._._._> tp) │ │ │ │ │ -176#endif │ │ │ │ │ -177 { │ │ │ │ │ -178 return Impl::child(std::forward(node),tp,std:: │ │ │ │ │ -index_sequence_for{}); │ │ │ │ │ -179 } │ │ │ │ │ -180 │ │ │ │ │ -181 template │ │ │ │ │ -182#ifdef DOXYGEN │ │ │ │ │ -183 ImplementationDefined _c_h_i_l_d (Node&& node, HybridTreePath │ │ │ │ │ -_t_r_e_e_P_a_t_h) │ │ │ │ │ -184#else │ │ │ │ │ -185 auto _c_h_i_l_d_S_t_o_r_a_g_e (Node&& node, HybridTreePath tp) │ │ │ │ │ -186#endif │ │ │ │ │ -187 { │ │ │ │ │ -188 static_assert(sizeof...(Indices) > 0, "childStorage() cannot be called with │ │ │ │ │ -an empty TreePath"); │ │ │ │ │ -189 return Impl::childStorage(&node,tp,std::index_sequence_for{}); │ │ │ │ │ -190 } │ │ │ │ │ -191 │ │ │ │ │ -192 │ │ │ │ │ -193#ifndef DOXYGEN │ │ │ │ │ -194 │ │ │ │ │ -195 namespace impl { │ │ │ │ │ -196 │ │ │ │ │ -197 template │ │ │ │ │ -198 struct filter_void │ │ │ │ │ -199 { │ │ │ │ │ -200 using type = T; │ │ │ │ │ -201 }; │ │ │ │ │ -202 │ │ │ │ │ -203 template<> │ │ │ │ │ -204 struct filter_void │ │ │ │ │ -205 {}; │ │ │ │ │ -206 │ │ │ │ │ -207 template │ │ │ │ │ -208 struct _Child │ │ │ │ │ -209 : public filter_void │ │ │ │ │ -(),index_constant{}...))>> │ │ │ │ │ -210 {}; │ │ │ │ │ -211 │ │ │ │ │ -212 } │ │ │ │ │ -213 │ │ │ │ │ -214#endif // DOXYGEN │ │ │ │ │ -215 │ │ │ │ │ -217 │ │ │ │ │ -224 template │ │ │ │ │ -_2_2_5 using _C_h_i_l_d = typename impl::_Child::type; │ │ │ │ │ -226 │ │ │ │ │ -227 │ │ │ │ │ -228#ifndef DOXYGEN │ │ │ │ │ -229 │ │ │ │ │ -230 namespace impl { │ │ │ │ │ -231 │ │ │ │ │ -232 template │ │ │ │ │ -233 struct _ChildForTreePath │ │ │ │ │ -234 { │ │ │ │ │ -235 using type = typename std::decay(),std:: │ │ │ │ │ -declval()))>::type; │ │ │ │ │ -236 }; │ │ │ │ │ -237 │ │ │ │ │ -238 } │ │ │ │ │ -239 │ │ │ │ │ -240#endif // DOXYGEN │ │ │ │ │ -241 │ │ │ │ │ -243 │ │ │ │ │ -251 template │ │ │ │ │ -_2_5_2 using _C_h_i_l_d_F_o_r_T_r_e_e_P_a_t_h = typename impl::_ChildForTreePath:: │ │ │ │ │ -type; │ │ │ │ │ -253 │ │ │ │ │ -254 │ │ │ │ │ -255#ifndef DOXYGEN │ │ │ │ │ -256 │ │ │ │ │ -257 namespace impl { │ │ │ │ │ -258 │ │ │ │ │ -259 // By default, types are flat indices if they are integral │ │ │ │ │ -260 template │ │ │ │ │ -261 struct _is_flat_index │ │ │ │ │ -262 { │ │ │ │ │ -263 using type = std::is_integral; │ │ │ │ │ -264 }; │ │ │ │ │ -265 │ │ │ │ │ -266 // And so is any index_constant │ │ │ │ │ -267 template │ │ │ │ │ -268 struct _is_flat_index> │ │ │ │ │ -269 { │ │ │ │ │ -270 using type = std::true_type; │ │ │ │ │ -271 }; │ │ │ │ │ -272 │ │ │ │ │ -273 } │ │ │ │ │ -274 │ │ │ │ │ -275#endif // DOXYGEN │ │ │ │ │ -276 │ │ │ │ │ -278 /* │ │ │ │ │ -279 * This type trait can be used to check whether T is a flat index (i.e. │ │ │ │ │ -either `std::size_t` │ │ │ │ │ -280 * or `index_constant`). The type trait normalizes T before doing the check, │ │ │ │ │ -so it will also │ │ │ │ │ -281 * work correctly for references and cv-qualified types. │ │ │ │ │ -282 */ │ │ │ │ │ -283 template │ │ │ │ │ -_2_8_4 using _i_s___f_l_a_t___i_n_d_e_x = typename impl::_is_flat_index>::type; │ │ │ │ │ -285 │ │ │ │ │ -286#ifndef DOXYGEN │ │ │ │ │ -287 │ │ │ │ │ -288 namespace impl { │ │ │ │ │ -289 │ │ │ │ │ -290 // helper function for check in member child() functions that tolerates │ │ │ │ │ -being passed something that │ │ │ │ │ -291 // isn't a TreePath. It will just return 0 in that case │ │ │ │ │ -292 │ │ │ │ │ -293 template │ │ │ │ │ -294 constexpr typename std::enable_if< │ │ │ │ │ -295 _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_s___f_l_a_t___i_n_d_e_x_<_T_>_:_:_v_a_l_u_e, │ │ │ │ │ -296 bool │ │ │ │ │ -297 >::type │ │ │ │ │ -298 _non_empty_tree_path (T) │ │ │ │ │ -299 { │ │ │ │ │ -300 return false; │ │ │ │ │ -301 } │ │ │ │ │ -302 │ │ │ │ │ -303 template │ │ │ │ │ -304 constexpr typename std::enable_if< │ │ │ │ │ -305 !_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_s___f_l_a_t___i_n_d_e_x_<_T_>_:_:_v_a_l_u_e, │ │ │ │ │ -306 bool │ │ │ │ │ -307 >::type │ │ │ │ │ -308 _non_empty_tree_path (T t) │ │ │ │ │ -309 { │ │ │ │ │ -310 return _t_r_e_e_P_a_t_h_S_i_z_e(t) > 0; │ │ │ │ │ -311 } │ │ │ │ │ -312 │ │ │ │ │ -313 } │ │ │ │ │ -314 │ │ │ │ │ -315#endif // DOXYGEN │ │ │ │ │ -316 │ │ │ │ │ -318 │ │ │ │ │ -319 } // namespace TypeTree │ │ │ │ │ -320} //namespace Dune │ │ │ │ │ -321 │ │ │ │ │ -322#endif // DUNE_TYPETREE_CHILDEXTRACTION_HH │ │ │ │ │ -_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h │ │ │ │ │ -_t_r_e_e_p_a_t_h_._h_h │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_i_s___f_l_a_t___i_n_d_e_x │ │ │ │ │ -typename impl::_is_flat_index< std::decay_t< T > >::type is_flat_index │ │ │ │ │ -Type trait that determines whether T is a flat index in the context of child │ │ │ │ │ -extraction. │ │ │ │ │ -DDeeffiinniittiioonn childextraction.hh:284 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ -ImplementationDefined childStorage(Node &&node, Indices... indices) │ │ │ │ │ -DDeeffiinniittiioonn childextraction.hh:138 │ │ │ │ │ -_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_:_:_C_h_i_l_d_F_o_r_T_r_e_e_P_a_t_h │ │ │ │ │ -typename impl::_ChildForTreePath< Node, TreePath >::type ChildForTreePath │ │ │ │ │ -Template alias for the type of a child node given by a TreePath or a │ │ │ │ │ -HybridTreePath type. │ │ │ │ │ -DDeeffiinniittiioonn childextraction.hh:252 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_t_r_e_e_P_a_t_h_S_i_z_e │ │ │ │ │ -constexpr std::size_t treePathSize(const HybridTreePath< T... > &) │ │ │ │ │ -Returns the size (number of components) of the given HybridTreePath. │ │ │ │ │ -DDeeffiinniittiioonn treepath.hh:334 │ │ │ │ │ -_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 │ │ │ │ │ +106 template │ │ │ │ │ +_1_0_7 using _S_t_a_t_i_c_D_e_g_r_e_e = decltype(Node::degree()); │ │ │ │ │ +108 │ │ │ │ │ +110 │ │ │ │ │ +111 } // namespace TypeTree │ │ │ │ │ +112} //namespace Dune │ │ │ │ │ +113 │ │ │ │ │ +114#endif // DUNE_TYPETREE_NODEINTERFACE_HH │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_d_e_g_r_e_e │ │ │ │ │ +std::size_t degree(const Node &node) │ │ │ │ │ +Returns the degree of node as run time information. │ │ │ │ │ +DDeeffiinniittiioonn nodeinterface.hh:79 │ │ │ │ │ +_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_:_:_I_m_p_l_e_m_e_n_t_a_t_i_o_n_T_a_g │ │ │ │ │ +typename std::decay_t< T >::ImplementationTag ImplementationTag │ │ │ │ │ +Returns the implementation tag of the given Node. │ │ │ │ │ +DDeeffiinniittiioonn nodeinterface.hh:74 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_D_e_g_r_e_e │ │ │ │ │ +decltype(Node::degree()) StaticDegree │ │ │ │ │ +Returns the statically known degree of the given Node type as a std:: │ │ │ │ │ +integral_constant. │ │ │ │ │ +DDeeffiinniittiioonn nodeinterface.hh:107 │ │ │ │ │ _D_u_n_e │ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_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_:_:_N_o_d_e_I_n_t_e_r_f_a_c_e │ │ │ │ │ +Interface for nodes in a dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn nodeinterface.hh:35 │ │ │ │ │ +_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_:_:_d_e_g_r_e_e │ │ │ │ │ +static auto degree() │ │ │ │ │ +Number of children of this node in the dune-typetree. │ │ │ │ │ +_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_:_:_i_s_P_o_w_e_r │ │ │ │ │ +static const bool isPower │ │ │ │ │ +Whether this is a power node in the dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn nodeinterface.hh:40 │ │ │ │ │ +_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_:_:_i_s_L_e_a_f │ │ │ │ │ +static const bool isLeaf │ │ │ │ │ +Whether this is a leaf node in a dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn nodeinterface.hh:37 │ │ │ │ │ +_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_:_:_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ +ImplementationDefined NodeStorage │ │ │ │ │ +container type to pass around a collection of children │ │ │ │ │ +DDeeffiinniittiioonn nodeinterface.hh:65 │ │ │ │ │ +_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_:_:_i_s_C_o_m_p_o_s_i_t_e │ │ │ │ │ +static const bool isComposite │ │ │ │ │ +Whether this is a composite node in the dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn nodeinterface.hh:43 │ │ │ │ │ +_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_:_:_N_o_d_e_T_a_g │ │ │ │ │ +ImplementationDefined NodeTag │ │ │ │ │ +The type tag that describes what kind of node this is. │ │ │ │ │ +DDeeffiinniittiioonn nodeinterface.hh:59 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00056.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: nodetags.hh File Reference │ │ │ │ +dune-typetree: traversalutilities.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -70,44 +70,102 @@ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    │ │ │ │ -Classes | │ │ │ │ -Namespaces
    │ │ │ │ -
    nodetags.hh File Reference
    │ │ │ │ +Namespaces | │ │ │ │ +Functions
    │ │ │ │ +
    traversalutilities.hh File Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │ - │ │ │ │ +
    #include <dune/typetree/traversal.hh>
    │ │ │ │ +
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -

    │ │ │ │ -Classes

    struct  Dune::TypeTree::LeafNodeTag
     Tag designating a leaf node. More...
     
    struct  Dune::TypeTree::PowerNodeTag
     Tag designating a power node. More...
     
    struct  Dune::TypeTree::DynamicPowerNodeTag
     Tag designating a power node with runtime degree. More...
     
    struct  Dune::TypeTree::CompositeNodeTag
     Tag designating a composite node. More...
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ +

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
     
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +

    │ │ │ │ +Functions

    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

    │ │ │ │ + │ │ │ │ +

    ◆ _functor

    │ │ │ │ + │ │ │ │ +
    │ │ │ │ +
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +
    F _functor
    │ │ │ │ +
    │ │ │ │ + │ │ │ │ +
    │ │ │ │ +
    │ │ │ │ + │ │ │ │ +

    ◆ _reduction

    │ │ │ │ + │ │ │ │ +
    │ │ │ │ +
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +
    R _reduction
    │ │ │ │ +
    │ │ │ │ + │ │ │ │ +
    │ │ │ │ +
    │ │ │ │ + │ │ │ │ +

    ◆ _value

    │ │ │ │ + │ │ │ │ +
    │ │ │ │ +
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +
    ResultType _value
    │ │ │ │ +
    │ │ │ │ + │ │ │ │ +
    │ │ │ │ +
    │ │ │ │ + │ │ │ │ +

    ◆ treePathType

    │ │ │ │ + │ │ │ │ +
    │ │ │ │ +
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +
    const TreePathType::Type treePathType = TreePathType::dynamic
    │ │ │ │ +     		│ │ │ │ +static
    │ │ │ │ +
    │ │ │ │ + │ │ │ │ +
    │ │ │ │ +
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,29 +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 │ │ │ │ │ -nodetags.hh File Reference │ │ │ │ │ +_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_:_:_L_e_a_f_N_o_d_e_T_a_g │ │ │ │ │ -  Tag designating a leaf node. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_T_a_g │ │ │ │ │ -  Tag designating a power node. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g │ │ │ │ │ -  Tag designating a power node with runtime degree. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g │ │ │ │ │ -  Tag designating a composite node. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ NNaammeessppaacceess │ │ │ │ │ namespace   _D_u_n_e │ │ │ │ │   │ │ │ │ │ namespace   _D_u_n_e_:_:_T_y_p_e_T_r_e_e │ │ │ │ │   │ │ │ │ │ +FFuunnccttiioonnss │ │ │ │ │ +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 ********** │ │ │ │ │ +********** _?◆_? __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/a00056_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: nodetags.hh Source File │ │ │ │ +dune-typetree: traversalutilities.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,54 +74,90 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ -
    nodetags.hh
    │ │ │ │ +
    traversalutilities.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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_NODETAGS_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_NODETAGS_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_TRAVERSALUTILITIES_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_TRAVERSALUTILITIES_HH
    │ │ │ │
    8
    │ │ │ │ -
    9namespace Dune {
    │ │ │ │ -
    10 namespace TypeTree {
    │ │ │ │ -
    11
    │ │ │ │ -
    18 struct LeafNodeTag {};
    │ │ │ │ -
    19
    │ │ │ │ -
    21 struct PowerNodeTag {};
    │ │ │ │ +
    9#include <dune/typetree/traversal.hh>
    │ │ │ │ +
    10
    │ │ │ │ +
    11namespace Dune {
    │ │ │ │ +
    12 namespace TypeTree {
    │ │ │ │ +
    13
    │ │ │ │ +
    19 namespace {
    │ │ │ │ +
    20
    │ │ │ │
    22
    │ │ │ │ -
    24 struct DynamicPowerNodeTag {};
    │ │ │ │ -
    25
    │ │ │ │ -
    27 struct CompositeNodeTag {};
    │ │ │ │ -
    28
    │ │ │ │ -
    29#ifndef DOXYGEN
    │ │ │ │ -
    30
    │ │ │ │ -
    32 struct StartTag {};
    │ │ │ │ +
    27 template<typename F, typename R, typename ResultType>
    │ │ │ │ +
    28 struct LeafReductionVisitor
    │ │ │ │ +
    29 : public TypeTree::TreeVisitor
    │ │ │ │ +
    30 {
    │ │ │ │ +
    31
    │ │ │ │ +
    32 static const TreePathType::Type treePathType = TreePathType::dynamic;
    │ │ │ │
    33
    │ │ │ │ -
    34
    │ │ │ │ -
    35
    │ │ │ │ -
    36#endif // DOXYGEN
    │ │ │ │ -
    37
    │ │ │ │ +
    34 template<typename Node, typename TreePath>
    │ │ │ │ +
    35 void leaf(const Node& node, TreePath treePath)
    │ │ │ │ +
    36 {
    │ │ │ │ +
    37 _value = _reduction(_value,_functor(node,treePath));
    │ │ │ │ +
    38 }
    │ │ │ │
    39
    │ │ │ │ -
    40 } // namespace TypeTree
    │ │ │ │ -
    41} //namespace Dune
    │ │ │ │ -
    42
    │ │ │ │ -
    43#endif // DUNE_TYPETREE_NODETAGS_HH
    │ │ │ │ +
    40 LeafReductionVisitor(F functor, R reduction, ResultType startValue)
    │ │ │ │ +
    41 : _functor(functor)
    │ │ │ │ +
    42 , _reduction(reduction)
    │ │ │ │ +
    43 , _value(startValue)
    │ │ │ │ +
    44 {}
    │ │ │ │ +
    45
    │ │ │ │ +
    46 ResultType result() { return _value; }
    │ │ │ │ +
    47
    │ │ │ │ +
    48 F _functor;
    │ │ │ │ +
    49 R _reduction;
    │ │ │ │ +
    50 ResultType _value;
    │ │ │ │ +
    51
    │ │ │ │ +
    52 };
    │ │ │ │ +
    53
    │ │ │ │ +
    54 } // anonymous namespace
    │ │ │ │ +
    55
    │ │ │ │ +
    57
    │ │ │ │ +
    82 template<typename ResultType, typename Tree, typename F, typename R>
    │ │ │ │ +
    │ │ │ │ +
    83 ResultType reduceOverLeafs(const Tree& tree, F functor, R reduction, ResultType startValue)
    │ │ │ │ +
    84 {
    │ │ │ │ +
    85 LeafReductionVisitor<F,R,ResultType> visitor(functor,reduction,startValue);
    │ │ │ │ +
    86 TypeTree::applyToTree(tree,visitor);
    │ │ │ │ +
    87 return visitor.result();
    │ │ │ │ +
    88 }
    │ │ │ │ +
    │ │ │ │ +
    89
    │ │ │ │ +
    91
    │ │ │ │ +
    92 } // namespace TypeTree
    │ │ │ │ +
    93} //namespace Dune
    │ │ │ │ +
    94
    │ │ │ │ +
    95#endif // DUNE_TYPETREE_TRAVERSALUTILITIES_HH
    │ │ │ │ +
    result
    static const result_type result
    Definition accumulate_static.hh:113
    │ │ │ │ +
    _reduction
    R _reduction
    Definition traversalutilities.hh:49
    │ │ │ │ +
    _functor
    F _functor
    Definition traversalutilities.hh:48
    │ │ │ │ +
    treePathType
    static const TreePathType::Type treePathType
    Definition traversalutilities.hh:32
    │ │ │ │ +
    _value
    ResultType _value
    Definition traversalutilities.hh:50
    │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::reduceOverLeafs
    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
    │ │ │ │ +
    Dune::TypeTree::applyToTree
    void applyToTree(Tree &&tree, Visitor &&visitor)
    Apply visitor to TypeTree.
    Definition traversal.hh:239
    │ │ │ │ +
    Dune::TypeTree::treePath
    constexpr auto treePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:326
    │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::LeafNodeTag
    Tag designating a leaf node.
    Definition nodetags.hh:18
    │ │ │ │ -
    Dune::TypeTree::PowerNodeTag
    Tag designating a power node.
    Definition nodetags.hh:21
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNodeTag
    Tag designating a power node with runtime degree.
    Definition nodetags.hh:24
    │ │ │ │ -
    Dune::TypeTree::CompositeNodeTag
    Tag designating a composite node.
    Definition nodetags.hh:27
    │ │ │ │ +
    Dune::TypeTree::TreePathType::Type
    Type
    Definition treepath.hh:106
    │ │ │ │ +
    Dune::TypeTree::TreePathType::dynamic
    @ dynamic
    Definition treepath.hh:106
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,58 +1,109 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -nodetags.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_NODETAGS_HH │ │ │ │ │ -7#define DUNE_TYPETREE_NODETAGS_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_TRAVERSALUTILITIES_HH │ │ │ │ │ +7#define DUNE_TYPETREE_TRAVERSALUTILITIES_HH │ │ │ │ │ 8 │ │ │ │ │ -9namespace _D_u_n_e { │ │ │ │ │ -10 namespace TypeTree { │ │ │ │ │ -11 │ │ │ │ │ -_1_8 struct _L_e_a_f_N_o_d_e_T_a_g {}; │ │ │ │ │ -19 │ │ │ │ │ -_2_1 struct _P_o_w_e_r_N_o_d_e_T_a_g {}; │ │ │ │ │ +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 │ │ │ │ │ -_2_4 struct _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g {}; │ │ │ │ │ -25 │ │ │ │ │ -_2_7 struct _C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g {}; │ │ │ │ │ -28 │ │ │ │ │ -29#ifndef DOXYGEN │ │ │ │ │ -30 │ │ │ │ │ -32 struct StartTag {}; │ │ │ │ │ +27 template │ │ │ │ │ +28 struct LeafReductionVisitor │ │ │ │ │ +29 : public TypeTree::TreeVisitor │ │ │ │ │ +30 { │ │ │ │ │ +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 │ │ │ │ │ -35 │ │ │ │ │ -36#endif // DOXYGEN │ │ │ │ │ -37 │ │ │ │ │ +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 } // namespace TypeTree │ │ │ │ │ -41} //namespace Dune │ │ │ │ │ -42 │ │ │ │ │ -43#endif // DUNE_TYPETREE_NODETAGS_HH │ │ │ │ │ +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 │ │ │ │ │ +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 │ │ │ │ │ +92 } // namespace TypeTree │ │ │ │ │ +93} //namespace Dune │ │ │ │ │ +94 │ │ │ │ │ +95#endif // DUNE_TYPETREE_TRAVERSALUTILITIES_HH │ │ │ │ │ +_r_e_s_u_l_t │ │ │ │ │ +static const result_type result │ │ │ │ │ +DDeeffiinniittiioonn accumulate_static.hh:113 │ │ │ │ │ +___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 │ │ │ │ │ +_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_:_:_L_e_a_f_N_o_d_e_T_a_g │ │ │ │ │ -Tag designating a leaf node. │ │ │ │ │ -DDeeffiinniittiioonn nodetags.hh:18 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_T_a_g │ │ │ │ │ -Tag designating a power node. │ │ │ │ │ -DDeeffiinniittiioonn nodetags.hh:21 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g │ │ │ │ │ -Tag designating a power node with runtime degree. │ │ │ │ │ -DDeeffiinniittiioonn nodetags.hh:24 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g │ │ │ │ │ -Tag designating a composite node. │ │ │ │ │ -DDeeffiinniittiioonn nodetags.hh:27 │ │ │ │ │ +_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/a00059.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: typetree.hh File Reference │ │ │ │ +dune-typetree: traversal.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -69,32 +69,80 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ -
    typetree.hh File Reference
    │ │ │ │ +
    │ │ │ │ +Namespaces | │ │ │ │ +Typedefs | │ │ │ │ +Functions
    │ │ │ │ +
    traversal.hh File Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │ -
    #include <dune/typetree/nodetags.hh>
    │ │ │ │ -#include <dune/typetree/utility.hh>
    │ │ │ │ -#include <dune/typetree/leafnode.hh>
    │ │ │ │ -#include <dune/typetree/powernode.hh>
    │ │ │ │ -#include <dune/typetree/dynamicpowernode.hh>
    │ │ │ │ -#include <dune/typetree/compositenode.hh>
    │ │ │ │ -#include <dune/typetree/traversal.hh>
    │ │ │ │ -#include <dune/typetree/pairtraversal.hh>
    │ │ │ │ -#include <dune/typetree/traversalutilities.hh>
    │ │ │ │ -#include <dune/typetree/transformation.hh>
    │ │ │ │ -#include <dune/typetree/transformationutilities.hh>
    │ │ │ │ -#include <dune/typetree/accumulate_static.hh>
    │ │ │ │ -#include <dune/typetree/childextraction.hh>
    │ │ │ │ +
    #include <utility>
    │ │ │ │ +#include <dune/common/hybridutilities.hh>
    │ │ │ │ +#include <dune/common/std/type_traits.hh>
    │ │ │ │ +#include <dune/typetree/childextraction.hh>
    │ │ │ │ +#include <dune/typetree/nodetags.hh>
    │ │ │ │ +#include <dune/typetree/treepath.hh>
    │ │ │ │ +#include <dune/typetree/visitor.hh>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +

    │ │ │ │ +Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
     
    namespace  Dune::TypeTree::Detail
     
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +

    │ │ │ │ +Typedefs

    template<class Tree >
    using Dune::TypeTree::Detail::DynamicTraversalConcept = decltype((std::declval< Tree >().degree(), std::declval< Tree >().child(0u)))
     
    template<class Tree >
    using Dune::TypeTree::Detail::StaticTraversalConcept = decltype((std::integral_constant< std::size_t, Tree::degree()>{}))
     
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +

    │ │ │ │ +Functions

    template<class Tree , TreePathType::Type pathType, class Prefix , std::enable_if_t< Tree::isLeaf, int > = 0>
    constexpr auto Dune::TypeTree::Detail::leafTreePathTuple (Prefix prefix)
     
    template<class Tree , TreePathType::Type pathType, class Prefix , std::size_t... indices, std::enable_if_t<(Tree::isComposite or(Tree::isPower and(pathType!=TreePathType::dynamic))), int > = 0>
    constexpr auto Dune::TypeTree::Detail::leafTreePathTuple (Prefix prefix, std::index_sequence< indices... >)
     
    template<class T , class TreePath , class V , std::enable_if_t< std::decay_t< T >::isLeaf, int > = 0>
    void Dune::TypeTree::Detail::applyToTree (T &&tree, TreePath treePath, V &&visitor)
     
    template<class T , class TreePath , class PreFunc , class LeafFunc , class PostFunc >
    void Dune::TypeTree::Detail::forEachNode (T &&tree, TreePath treePath, PreFunc &&preFunc, LeafFunc &&leafFunc, PostFunc &&postFunc)
     
    template<class Tree , TreePathType::Type pathType = TreePathType::dynamic>
    constexpr auto Dune::TypeTree::leafTreePathTuple ()
     Create tuple of tree paths to leafs.
     
    template<typename Tree , typename Visitor >
    void Dune::TypeTree::applyToTree (Tree &&tree, Visitor &&visitor)
     Apply visitor to TypeTree.
     
    template<class Tree , class NodeFunc >
    void Dune::TypeTree::forEachNode (Tree &&tree, NodeFunc &&nodeFunc)
     Traverse tree and visit each node.
     
    template<class Tree , class LeafFunc >
    void Dune::TypeTree::forEachLeafNode (Tree &&tree, LeafFunc &&leafFunc)
     Traverse tree and visit each leaf node.
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,23 +1,73 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -typetree.hh File Reference │ │ │ │ │ -#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_/_u_t_i_l_i_t_y_._h_h> │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_l_e_a_f_n_o_d_e_._h_h> │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_p_o_w_e_r_n_o_d_e_._h_h> │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_d_y_n_a_m_i_c_p_o_w_e_r_n_o_d_e_._h_h> │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_c_o_m_p_o_s_i_t_e_n_o_d_e_._h_h> │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_v_e_r_s_a_l_._h_h> │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_p_a_i_r_t_r_a_v_e_r_s_a_l_._h_h> │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_v_e_r_s_a_l_u_t_i_l_i_t_i_e_s_._h_h> │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_n_s_f_o_r_m_a_t_i_o_n_._h_h> │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_n_s_f_o_r_m_a_t_i_o_n_u_t_i_l_i_t_i_e_s_._h_h> │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_a_c_c_u_m_u_l_a_t_e___s_t_a_t_i_c_._h_h> │ │ │ │ │ +_N_a_m_e_s_p_a_c_e_s | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s │ │ │ │ │ +traversal.hh File Reference │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ #include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._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_/_v_i_s_i_t_o_r_._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_. │ │ │ │ │ +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_:_:_D_e_t_a_i_l │ │ │ │ │ +  │ │ │ │ │ +TTyyppeeddeeffss │ │ │ │ │ +template │ │ │ │ │ +using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_D_y_n_a_m_i_c_T_r_a_v_e_r_s_a_l_C_o_n_c_e_p_t = decltype((std:: │ │ │ │ │ + declval< Tree >()._d_e_g_r_e_e(), std::declval< Tree >()._c_h_i_l_d(0u))) │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ +using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_S_t_a_t_i_c_T_r_a_v_e_r_s_a_l_C_o_n_c_e_p_t = decltype((std:: │ │ │ │ │ + integral_constant< std::size_t, Tree::degree()>{})) │ │ │ │ │ +  │ │ │ │ │ +FFuunnccttiioonnss │ │ │ │ │ +template = 0> │ │ │ │ │ +constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e (Prefix prefix) │ │ │ │ │ +  │ │ │ │ │ +template = 0> │ │ │ │ │ +constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e (Prefix prefix, std:: │ │ │ │ │ + index_sequence< indices... >) │ │ │ │ │ +  │ │ │ │ │ +template::isLeaf, int > = 0> │ │ │ │ │ + void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_a_p_p_l_y_T_o_T_r_e_e (T &&tree, TreePath │ │ │ │ │ + _t_r_e_e_P_a_t_h, V &&visitor) │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_f_o_r_E_a_c_h_N_o_d_e (T &&tree, TreePath │ │ │ │ │ + _t_r_e_e_P_a_t_h, PreFunc &&preFunc, LeafFunc &&leafFunc, PostFunc │ │ │ │ │ + &&postFunc) │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ +constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e () │ │ │ │ │ +  Create tuple of tree paths to leafs. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_p_p_l_y_T_o_T_r_e_e (Tree &&tree, Visitor &&visitor) │ │ │ │ │ +  Apply visitor to _T_y_p_e_T_r_e_e. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_o_r_E_a_c_h_N_o_d_e (Tree &&tree, NodeFunc &&nodeFunc) │ │ │ │ │ +  Traverse tree and visit each node. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_o_r_E_a_c_h_L_e_a_f_N_o_d_e (Tree &&tree, LeafFunc │ │ │ │ │ + &&leafFunc) │ │ │ │ │ +  Traverse tree and visit each leaf node. │ │ │ │ │ +  │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00059_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: typetree.hh Source File │ │ │ │ +dune-typetree: traversal.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,53 +74,281 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -
    typetree.hh
    │ │ │ │ +
    traversal.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_TRAVERSAL_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_TRAVERSAL_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <dune/typetree/nodetags.hh>
    │ │ │ │ -
    10#include <dune/typetree/utility.hh>
    │ │ │ │ -
    11#include <dune/typetree/leafnode.hh>
    │ │ │ │ -
    12#include <dune/typetree/powernode.hh>
    │ │ │ │ -
    13#include <dune/typetree/dynamicpowernode.hh>
    │ │ │ │ -
    14#include <dune/typetree/compositenode.hh>
    │ │ │ │ -
    15#include <dune/typetree/traversal.hh>
    │ │ │ │ -
    16#include <dune/typetree/pairtraversal.hh>
    │ │ │ │ -
    17#include <dune/typetree/traversalutilities.hh>
    │ │ │ │ -
    18#include <dune/typetree/transformation.hh>
    │ │ │ │ -
    19#include <dune/typetree/transformationutilities.hh>
    │ │ │ │ -
    20#include <dune/typetree/accumulate_static.hh>
    │ │ │ │ -
    21#include <dune/typetree/childextraction.hh>
    │ │ │ │ -
    22
    │ │ │ │ -
    23#endif // DUNE_TYPETREE_HH
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ +
    9#include <utility>
    │ │ │ │ +
    10
    │ │ │ │ +
    11#include <dune/common/hybridutilities.hh>
    │ │ │ │ +
    12#include <dune/common/std/type_traits.hh>
    │ │ │ │ +
    13
    │ │ │ │ +
    14#include <dune/typetree/childextraction.hh>
    │ │ │ │ +
    15#include <dune/typetree/nodetags.hh>
    │ │ │ │ +
    16#include <dune/typetree/treepath.hh>
    │ │ │ │ +
    17#include <dune/typetree/visitor.hh>
    │ │ │ │ +
    18
    │ │ │ │ +
    19namespace Dune {
    │ │ │ │ +
    20 namespace TypeTree {
    │ │ │ │ +
    21
    │ │ │ │ +
    27#ifndef DOXYGEN
    │ │ │ │ +
    29 struct NoOp
    │ │ │ │ +
    30 {
    │ │ │ │ +
    31 template<class... T>
    │ │ │ │ +
    32 constexpr void operator()(T&&...) const { /* do nothing */ }
    │ │ │ │ +
    33 };
    │ │ │ │ +
    34#endif
    │ │ │ │ +
    35
    │ │ │ │ +
    36 namespace Detail {
    │ │ │ │ +
    37
    │ │ │ │ +
    38 // SFINAE template check that Tree has a degree() function and a child() function accepting integer indices
    │ │ │ │ +
    39 template<class Tree>
    │ │ │ │ +
    40 using DynamicTraversalConcept = decltype((
    │ │ │ │ +
    41 std::declval<Tree>().degree(),
    │ │ │ │ +
    42 std::declval<Tree>().child(0u)
    │ │ │ │ +
    43 ));
    │ │ │ │ +
    44
    │ │ │ │ +
    45 // SFINAE template check that Tree has static (constexpr) function Tree::degree()
    │ │ │ │ +
    46 template<class Tree>
    │ │ │ │ +
    47 using StaticTraversalConcept = decltype((
    │ │ │ │ +
    48 std::integral_constant<std::size_t, Tree::degree()>{}
    │ │ │ │ +
    49 ));
    │ │ │ │ +
    50
    │ │ │ │ +
    51
    │ │ │ │ +
    52 template<class Tree, TreePathType::Type pathType, class Prefix,
    │ │ │ │ +
    53 std::enable_if_t<Tree::isLeaf, int> = 0>
    │ │ │ │ +
    │ │ │ │ +
    54 constexpr auto leafTreePathTuple(Prefix prefix)
    │ │ │ │ +
    55 {
    │ │ │ │ +
    56 return std::make_tuple(prefix);
    │ │ │ │ +
    57 }
    │ │ │ │ +
    │ │ │ │ +
    58
    │ │ │ │ +
    59 template<class Tree, TreePathType::Type pathType, class Prefix,
    │ │ │ │ +
    60 std::enable_if_t<not Tree::isLeaf, int> = 0>
    │ │ │ │ +
    61 constexpr auto leafTreePathTuple(Prefix prefix);
    │ │ │ │ +
    62
    │ │ │ │ +
    63 template<class Tree, TreePathType::Type pathType, class Prefix, std::size_t... indices,
    │ │ │ │ +
    64 std::enable_if_t<(Tree::isComposite or (Tree::isPower and (pathType!=TreePathType::dynamic))), int> = 0>
    │ │ │ │ +
    │ │ │ │ +
    65 constexpr auto leafTreePathTuple(Prefix prefix, std::index_sequence<indices...>)
    │ │ │ │ +
    66 {
    │ │ │ │ +
    67 return std::tuple_cat(Detail::leafTreePathTuple<TypeTree::Child<Tree,indices>, pathType>(Dune::TypeTree::push_back(prefix, Dune::index_constant<indices>{}))...);
    │ │ │ │ +
    68 }
    │ │ │ │ +
    │ │ │ │ +
    69
    │ │ │ │ +
    70 template<class Tree, TreePathType::Type pathType, class Prefix, std::size_t... indices,
    │ │ │ │ +
    71 std::enable_if_t<(Tree::isPower and (pathType==TreePathType::dynamic)), int> = 0>
    │ │ │ │ +
    72 constexpr auto leafTreePathTuple(Prefix prefix, std::index_sequence<indices...>)
    │ │ │ │ +
    73 {
    │ │ │ │ +
    74 return std::tuple_cat(Detail::leafTreePathTuple<TypeTree::Child<Tree,indices>, pathType>(Dune::TypeTree::push_back(prefix, indices))...);
    │ │ │ │ +
    75 }
    │ │ │ │ +
    76
    │ │ │ │ +
    77 template<class Tree, TreePathType::Type pathType, class Prefix,
    │ │ │ │ +
    78 std::enable_if_t<not Tree::isLeaf, int>>
    │ │ │ │ +
    79 constexpr auto leafTreePathTuple(Prefix prefix)
    │ │ │ │ +
    80 {
    │ │ │ │ +
    81 return Detail::leafTreePathTuple<Tree, pathType>(prefix, std::make_index_sequence<Tree::degree()>{});
    │ │ │ │ +
    82 }
    │ │ │ │ +
    83
    │ │ │ │ +
    84 /* The signature is the same as for the public applyToTree
    │ │ │ │ +
    85 * function in Dune::Typetree, despite the additionally passed
    │ │ │ │ +
    86 * treePath argument. The path passed here is associated to
    │ │ │ │ +
    87 * the tree and the relative paths of the children (wrt. to tree)
    │ │ │ │ +
    88 * are appended to this. Hence the behavior of the public function
    │ │ │ │ +
    89 * is resembled by passing an empty treePath.
    │ │ │ │ +
    90 */
    │ │ │ │ +
    91
    │ │ │ │ +
    92 /*
    │ │ │ │ +
    93 * This is the overload for leaf traversal
    │ │ │ │ +
    94 */
    │ │ │ │ +
    95 template<class T, class TreePath, class V,
    │ │ │ │ +
    96 std::enable_if_t<std::decay_t<T>::isLeaf, int> = 0>
    │ │ │ │ +
    │ │ │ │ +
    97 void applyToTree(T&& tree, TreePath treePath, V&& visitor)
    │ │ │ │ +
    98 {
    │ │ │ │ +
    99 visitor.leaf(tree, treePath);
    │ │ │ │ +
    100 }
    │ │ │ │ +
    │ │ │ │ +
    101
    │ │ │ │ +
    102 /*
    │ │ │ │ +
    103 * This is the general overload doing child traversal.
    │ │ │ │ +
    104 */
    │ │ │ │ +
    105 template<class T, class TreePath, class V,
    │ │ │ │ +
    106 std::enable_if_t<not std::decay_t<T>::isLeaf, int> = 0>
    │ │ │ │ +
    107 void applyToTree(T&& tree, TreePath treePath, V&& visitor)
    │ │ │ │ +
    108 {
    │ │ │ │ +
    109 using Tree = std::remove_reference_t<T>;
    │ │ │ │ +
    110 using Visitor = std::remove_reference_t<V>;
    │ │ │ │ +
    111 visitor.pre(tree, treePath);
    │ │ │ │ +
    112
    │ │ │ │ +
    113 // check which type of traversal is supported by the tree
    │ │ │ │ +
    114 using allowDynamicTraversal = Dune::Std::is_detected<DynamicTraversalConcept,Tree>;
    │ │ │ │ +
    115 using allowStaticTraversal = Dune::Std::is_detected<StaticTraversalConcept,Tree>;
    │ │ │ │ +
    116
    │ │ │ │ +
    117 // the tree must support either dynamic or static traversal
    │ │ │ │ +
    118 static_assert(allowDynamicTraversal::value || allowStaticTraversal::value);
    │ │ │ │ +
    119
    │ │ │ │ +
    120 // the visitor may specify preferred dynamic traversal
    │ │ │ │ +
    121 using preferDynamicTraversal = std::bool_constant<Visitor::treePathType == TreePathType::dynamic>;
    │ │ │ │ +
    122
    │ │ │ │ +
    123 // create a dynamic or static index range
    │ │ │ │ +
    124 auto indices = [&]{
    │ │ │ │ +
    125 if constexpr(preferDynamicTraversal::value && allowDynamicTraversal::value)
    │ │ │ │ +
    126 return Dune::range(std::size_t(tree.degree()));
    │ │ │ │ +
    127 else
    │ │ │ │ +
    128 return Dune::range(tree.degree());
    │ │ │ │ +
    129 }();
    │ │ │ │ +
    130
    │ │ │ │ +
    131 if constexpr(allowDynamicTraversal::value || allowStaticTraversal::value) {
    │ │ │ │ +
    132 Hybrid::forEach(indices, [&](auto i) {
    │ │ │ │ +
    133 auto&& child = tree.child(i);
    │ │ │ │ +
    134 using Child = std::decay_t<decltype(child)>;
    │ │ │ │ +
    135
    │ │ │ │ +
    136 visitor.beforeChild(tree, child, treePath, i);
    │ │ │ │ +
    137
    │ │ │ │ +
    138 // This requires that visitor.in(...) can always be instantiated,
    │ │ │ │ +
    139 // even if there's a single child only.
    │ │ │ │ +
    140 if (i>0)
    │ │ │ │ +
    141 visitor.in(tree, treePath);
    │ │ │ │ +
    142
    │ │ │ │ +
    143 constexpr bool visitChild = Visitor::template VisitChild<Tree,Child,TreePath>::value;
    │ │ │ │ +
    144 if constexpr(visitChild) {
    │ │ │ │ +
    145 auto childTreePath = Dune::TypeTree::push_back(treePath, i);
    │ │ │ │ +
    146 applyToTree(child, childTreePath, visitor);
    │ │ │ │ +
    147 }
    │ │ │ │ +
    148
    │ │ │ │ +
    149 visitor.afterChild(tree, child, treePath, i);
    │ │ │ │ +
    150 });
    │ │ │ │ +
    151 }
    │ │ │ │ +
    152 visitor.post(tree, treePath);
    │ │ │ │ +
    153 }
    │ │ │ │ +
    154
    │ │ │ │ +
    155 /* Traverse tree and visit each node. The signature is the same
    │ │ │ │ +
    156 * as for the public forEachNode function in Dune::Typtree,
    │ │ │ │ +
    157 * despite the additionally passed treePath argument. The path
    │ │ │ │ +
    158 * passed here is associated to the tree and the relative
    │ │ │ │ +
    159 * paths of the children (wrt. to tree) are appended to this.
    │ │ │ │ +
    160 * Hence the behavior of the public function is resembled
    │ │ │ │ +
    161 * by passing an empty treePath.
    │ │ │ │ +
    162 */
    │ │ │ │ +
    163 template<class T, class TreePath, class PreFunc, class LeafFunc, class PostFunc>
    │ │ │ │ +
    │ │ │ │ +
    164 void forEachNode(T&& tree, TreePath treePath, PreFunc&& preFunc, LeafFunc&& leafFunc, PostFunc&& postFunc)
    │ │ │ │ +
    165 {
    │ │ │ │ +
    166 using Tree = std::decay_t<T>;
    │ │ │ │ +
    167 if constexpr(Tree::isLeaf) {
    │ │ │ │ +
    168 leafFunc(tree, treePath);
    │ │ │ │ +
    169 } else {
    │ │ │ │ +
    170 preFunc(tree, treePath);
    │ │ │ │ +
    171
    │ │ │ │ +
    172 // check which type of traversal is supported by the tree, prefer dynamic traversal
    │ │ │ │ +
    173 using allowDynamicTraversal = Dune::Std::is_detected<DynamicTraversalConcept,Tree>;
    │ │ │ │ +
    174 using allowStaticTraversal = Dune::Std::is_detected<StaticTraversalConcept,Tree>;
    │ │ │ │ +
    175
    │ │ │ │ +
    176 // the tree must support either dynamic or static traversal
    │ │ │ │ +
    177 static_assert(allowDynamicTraversal::value || allowStaticTraversal::value);
    │ │ │ │ +
    178
    │ │ │ │ +
    179 if constexpr(allowDynamicTraversal::value) {
    │ │ │ │ +
    180 // Specialization for dynamic traversal
    │ │ │ │ +
    181 for (std::size_t i = 0; i < tree.degree(); ++i) {
    │ │ │ │ +
    182 auto childTreePath = Dune::TypeTree::push_back(treePath, i);
    │ │ │ │ +
    183 forEachNode(tree.child(i), childTreePath, preFunc, leafFunc, postFunc);
    │ │ │ │ +
    184 }
    │ │ │ │ +
    185 } else if constexpr(allowStaticTraversal::value) {
    │ │ │ │ +
    186 // Specialization for static traversal
    │ │ │ │ +
    187 auto indices = std::make_index_sequence<Tree::degree()>{};
    │ │ │ │ +
    188 Hybrid::forEach(indices, [&](auto i) {
    │ │ │ │ +
    189 auto childTreePath = Dune::TypeTree::push_back(treePath, i);
    │ │ │ │ +
    190 forEachNode(tree.child(i), childTreePath, preFunc, leafFunc, postFunc);
    │ │ │ │ +
    191 });
    │ │ │ │ +
    192 }
    │ │ │ │ +
    193 postFunc(tree, treePath);
    │ │ │ │ +
    194 }
    │ │ │ │ +
    195 }
    │ │ │ │ +
    │ │ │ │ +
    196
    │ │ │ │ +
    197 } // namespace Detail
    │ │ │ │ +
    198
    │ │ │ │ +
    199
    │ │ │ │ +
    200 // ********************************************************************************
    │ │ │ │ +
    201 // Public Interface
    │ │ │ │ +
    202 // ********************************************************************************
    │ │ │ │ +
    203
    │ │ │ │ +
    217 template<class Tree, TreePathType::Type pathType=TreePathType::dynamic>
    │ │ │ │ +
    │ │ │ │ +
    218 constexpr auto leafTreePathTuple()
    │ │ │ │ +
    219 {
    │ │ │ │ +
    220 return Detail::leafTreePathTuple<std::decay_t<Tree>, pathType>(hybridTreePath());
    │ │ │ │ +
    221 }
    │ │ │ │ +
    │ │ │ │ +
    222
    │ │ │ │ +
    224
    │ │ │ │ +
    238 template<typename Tree, typename Visitor>
    │ │ │ │ +
    │ │ │ │ +
    239 void applyToTree(Tree&& tree, Visitor&& visitor)
    │ │ │ │ +
    240 {
    │ │ │ │ +
    241 Detail::applyToTree(tree, hybridTreePath(), visitor);
    │ │ │ │ +
    242 }
    │ │ │ │ +
    │ │ │ │ +
    243
    │ │ │ │ +
    253 template<class Tree, class NodeFunc>
    │ │ │ │ +
    │ │ │ │ +
    254 void forEachNode(Tree&& tree, NodeFunc&& nodeFunc)
    │ │ │ │ +
    255 {
    │ │ │ │ +
    256 Detail::forEachNode(tree, hybridTreePath(), nodeFunc, nodeFunc, NoOp{});
    │ │ │ │ +
    257 }
    │ │ │ │ +
    │ │ │ │ +
    258
    │ │ │ │ +
    268 template<class Tree, class LeafFunc>
    │ │ │ │ +
    │ │ │ │ +
    269 void forEachLeafNode(Tree&& tree, LeafFunc&& leafFunc)
    │ │ │ │ +
    270 {
    │ │ │ │ +
    271 Detail::forEachNode(tree, hybridTreePath(), NoOp{}, leafFunc, NoOp{});
    │ │ │ │ +
    272 }
    │ │ │ │ +
    │ │ │ │ +
    273
    │ │ │ │ +
    275
    │ │ │ │ +
    276 } // namespace TypeTree
    │ │ │ │ +
    277} //namespace Dune
    │ │ │ │ +
    278
    │ │ │ │ +
    279#endif // DUNE_TYPETREE_TRAVERSAL_HH
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::forEachNode
    void forEachNode(Tree &&tree, NodeFunc &&nodeFunc)
    Traverse tree and visit each node.
    Definition traversal.hh:254
    │ │ │ │ +
    Dune::TypeTree::leafTreePathTuple
    constexpr auto leafTreePathTuple()
    Create tuple of tree paths to leafs.
    Definition traversal.hh:218
    │ │ │ │ +
    Dune::TypeTree::forEachLeafNode
    void forEachLeafNode(Tree &&tree, LeafFunc &&leafFunc)
    Traverse tree and visit each leaf node.
    Definition traversal.hh:269
    │ │ │ │ +
    Dune::TypeTree::applyToTree
    void applyToTree(Tree &&tree, Visitor &&visitor)
    Apply visitor to TypeTree.
    Definition traversal.hh:239
    │ │ │ │ +
    Dune::TypeTree::Child
    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
    │ │ │ │ +
    Dune::TypeTree::child
    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
    │ │ │ │ +
    Dune::TypeTree::push_back
    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
    │ │ │ │ +
    Dune::TypeTree::hybridTreePath
    constexpr auto hybridTreePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:312
    │ │ │ │ +
    Dune::TypeTree::treePath
    constexpr auto treePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:326
    │ │ │ │ +
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ +
    Dune::TypeTree::Detail::forEachNode
    void forEachNode(T &&tree, TreePath treePath, PreFunc &&preFunc, LeafFunc &&leafFunc, PostFunc &&postFunc)
    Definition traversal.hh:164
    │ │ │ │ +
    Dune::TypeTree::Detail::DynamicTraversalConcept
    decltype((std::declval< Tree >().degree(), std::declval< Tree >().child(0u))) DynamicTraversalConcept
    Definition traversal.hh:43
    │ │ │ │ +
    Dune::TypeTree::Detail::StaticTraversalConcept
    decltype((std::integral_constant< std::size_t, Tree::degree()>{})) StaticTraversalConcept
    Definition traversal.hh:49
    │ │ │ │ +
    Dune::TypeTree::Detail::applyToTree
    void applyToTree(T &&tree, TreePath treePath, V &&visitor)
    Definition traversal.hh:97
    │ │ │ │ +
    Dune::TypeTree::Detail::leafTreePathTuple
    constexpr auto leafTreePathTuple(Prefix prefix)
    Definition traversal.hh:54
    │ │ │ │ +
    Dune::TypeTree::TreePathType::Type
    Type
    Definition treepath.hh:106
    │ │ │ │ +
    Dune::TypeTree::TreePathType::dynamic
    @ dynamic
    Definition treepath.hh:106
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,48 +1,333 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -typetree.hh │ │ │ │ │ +traversal.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_HH │ │ │ │ │ -7#define DUNE_TYPETREE_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_TRAVERSAL_HH │ │ │ │ │ +7#define DUNE_TYPETREE_TRAVERSAL_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ -10#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_u_t_i_l_i_t_y_._h_h> │ │ │ │ │ -11#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_l_e_a_f_n_o_d_e_._h_h> │ │ │ │ │ -12#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_p_o_w_e_r_n_o_d_e_._h_h> │ │ │ │ │ -13#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_d_y_n_a_m_i_c_p_o_w_e_r_n_o_d_e_._h_h> │ │ │ │ │ -14#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_c_o_m_p_o_s_i_t_e_n_o_d_e_._h_h> │ │ │ │ │ -15#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_v_e_r_s_a_l_._h_h> │ │ │ │ │ -16#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_p_a_i_r_t_r_a_v_e_r_s_a_l_._h_h> │ │ │ │ │ -17#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_v_e_r_s_a_l_u_t_i_l_i_t_i_e_s_._h_h> │ │ │ │ │ -18#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_n_s_f_o_r_m_a_t_i_o_n_._h_h> │ │ │ │ │ -19#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_n_s_f_o_r_m_a_t_i_o_n_u_t_i_l_i_t_i_e_s_._h_h> │ │ │ │ │ -20#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_a_c_c_u_m_u_l_a_t_e___s_t_a_t_i_c_._h_h> │ │ │ │ │ -21#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h> │ │ │ │ │ -22 │ │ │ │ │ -23#endif // DUNE_TYPETREE_HH │ │ │ │ │ -_t_r_a_n_s_f_o_r_m_a_t_i_o_n_._h_h │ │ │ │ │ -_c_o_m_p_o_s_i_t_e_n_o_d_e_._h_h │ │ │ │ │ -_a_c_c_u_m_u_l_a_t_e___s_t_a_t_i_c_._h_h │ │ │ │ │ -_p_o_w_e_r_n_o_d_e_._h_h │ │ │ │ │ -_u_t_i_l_i_t_y_._h_h │ │ │ │ │ -_t_r_a_n_s_f_o_r_m_a_t_i_o_n_u_t_i_l_i_t_i_e_s_._h_h │ │ │ │ │ +9#include │ │ │ │ │ +10 │ │ │ │ │ +11#include │ │ │ │ │ +12#include │ │ │ │ │ +13 │ │ │ │ │ +14#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h> │ │ │ │ │ +15#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ +16#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_e_e_p_a_t_h_._h_h> │ │ │ │ │ +17#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_v_i_s_i_t_o_r_._h_h> │ │ │ │ │ +18 │ │ │ │ │ +19namespace _D_u_n_e { │ │ │ │ │ +20 namespace TypeTree { │ │ │ │ │ +21 │ │ │ │ │ +27#ifndef DOXYGEN │ │ │ │ │ +29 struct NoOp │ │ │ │ │ +30 { │ │ │ │ │ +31 template │ │ │ │ │ +32 constexpr void operator()(T&&...) const { /* do nothing */ } │ │ │ │ │ +33 }; │ │ │ │ │ +34#endif │ │ │ │ │ +35 │ │ │ │ │ +36 namespace Detail { │ │ │ │ │ +37 │ │ │ │ │ +38 // SFINAE template check that Tree has a degree() function and a child() │ │ │ │ │ +function accepting integer indices │ │ │ │ │ +39 template │ │ │ │ │ +_4_0 using _D_y_n_a_m_i_c_T_r_a_v_e_r_s_a_l_C_o_n_c_e_p_t = decltype(( │ │ │ │ │ +41 std::declval().degree(), │ │ │ │ │ +42 std::declval().child(0u) │ │ │ │ │ +43 )); │ │ │ │ │ +44 │ │ │ │ │ +45 // SFINAE template check that Tree has static (constexpr) function Tree:: │ │ │ │ │ +degree() │ │ │ │ │ +46 template │ │ │ │ │ +_4_7 using _S_t_a_t_i_c_T_r_a_v_e_r_s_a_l_C_o_n_c_e_p_t = decltype(( │ │ │ │ │ +48 std::integral_constant{} │ │ │ │ │ +49 )); │ │ │ │ │ +50 │ │ │ │ │ +51 │ │ │ │ │ +52 template = 0> │ │ │ │ │ +_5_4 constexpr auto _l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e(Prefix prefix) │ │ │ │ │ +55 { │ │ │ │ │ +56 return std::make_tuple(prefix); │ │ │ │ │ +57 } │ │ │ │ │ +58 │ │ │ │ │ +59 template = 0> │ │ │ │ │ +61 constexpr auto _l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e(Prefix prefix); │ │ │ │ │ +62 │ │ │ │ │ +63 template = 0> │ │ │ │ │ +_6_5 constexpr auto _l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e(Prefix prefix, std:: │ │ │ │ │ +index_sequence) │ │ │ │ │ +66 { │ │ │ │ │ +67 return std::tuple_cat(_D_e_t_a_i_l_:_:_l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e<_T_y_p_e_T_r_e_e_:_: │ │ │ │ │ +_C_h_i_l_d_<_T_r_e_e_,_i_n_d_i_c_e_s_>, pathType>(_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_u_s_h___b_a_c_k(prefix, Dune:: │ │ │ │ │ +index_constant{}))...); │ │ │ │ │ +68 } │ │ │ │ │ +69 │ │ │ │ │ +70 template │ │ │ │ │ += 0> │ │ │ │ │ +72 constexpr auto _l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e(Prefix prefix, std:: │ │ │ │ │ +index_sequence) │ │ │ │ │ +73 { │ │ │ │ │ +74 return std::tuple_cat(_D_e_t_a_i_l_:_:_l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e<_T_y_p_e_T_r_e_e_:_: │ │ │ │ │ +_C_h_i_l_d_<_T_r_e_e_,_i_n_d_i_c_e_s_>, pathType>(_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_u_s_h___b_a_c_k(prefix, indices))...); │ │ │ │ │ +75 } │ │ │ │ │ +76 │ │ │ │ │ +77 template> │ │ │ │ │ +79 constexpr auto _l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e(Prefix prefix) │ │ │ │ │ +80 { │ │ │ │ │ +81 return Detail::leafTreePathTuple(prefix, std:: │ │ │ │ │ +make_index_sequence{}); │ │ │ │ │ +82 } │ │ │ │ │ +83 │ │ │ │ │ +84 /* The signature is the same as for the public applyToTree │ │ │ │ │ +85 * function in Dune::Typetree, despite the additionally passed │ │ │ │ │ +86 * treePath argument. The path passed here is associated to │ │ │ │ │ +87 * the tree and the relative paths of the children (wrt. to tree) │ │ │ │ │ +88 * are appended to this. Hence the behavior of the public function │ │ │ │ │ +89 * is resembled by passing an empty treePath. │ │ │ │ │ +90 */ │ │ │ │ │ +91 │ │ │ │ │ +92 /* │ │ │ │ │ +93 * This is the overload for leaf traversal │ │ │ │ │ +94 */ │ │ │ │ │ +95 template::isLeaf, int> = 0> │ │ │ │ │ +_9_7 void _a_p_p_l_y_T_o_T_r_e_e(T&& tree, TreePath _t_r_e_e_P_a_t_h, V&& visitor) │ │ │ │ │ +98 { │ │ │ │ │ +99 visitor.leaf(tree, _t_r_e_e_P_a_t_h); │ │ │ │ │ +100 } │ │ │ │ │ +101 │ │ │ │ │ +102 /* │ │ │ │ │ +103 * This is the general overload doing child traversal. │ │ │ │ │ +104 */ │ │ │ │ │ +105 template::isLeaf, int> = 0> │ │ │ │ │ +107 void _a_p_p_l_y_T_o_T_r_e_e(T&& tree, TreePath _t_r_e_e_P_a_t_h, V&& visitor) │ │ │ │ │ +108 { │ │ │ │ │ +109 using Tree = std::remove_reference_t; │ │ │ │ │ +110 using Visitor = std::remove_reference_t; │ │ │ │ │ +111 visitor.pre(tree, _t_r_e_e_P_a_t_h); │ │ │ │ │ +112 │ │ │ │ │ +113 // check which type of traversal is supported by the tree │ │ │ │ │ +114 using allowDynamicTraversal = Dune::Std:: │ │ │ │ │ +is_detected; │ │ │ │ │ +115 using allowStaticTraversal = Dune::Std:: │ │ │ │ │ +is_detected; │ │ │ │ │ +116 │ │ │ │ │ +117 // the tree must support either dynamic or static traversal │ │ │ │ │ +118 static_assert(allowDynamicTraversal::value || allowStaticTraversal::value); │ │ │ │ │ +119 │ │ │ │ │ +120 // the visitor may specify preferred dynamic traversal │ │ │ │ │ +121 using preferDynamicTraversal = std::bool_constant; │ │ │ │ │ +122 │ │ │ │ │ +123 // create a dynamic or static index range │ │ │ │ │ +124 auto indices = [&]{ │ │ │ │ │ +125 if constexpr(preferDynamicTraversal::value && allowDynamicTraversal::value) │ │ │ │ │ +126 return Dune::range(std::size_t(tree.degree())); │ │ │ │ │ +127 else │ │ │ │ │ +128 return Dune::range(tree.degree()); │ │ │ │ │ +129 }(); │ │ │ │ │ +130 │ │ │ │ │ +131 if constexpr(allowDynamicTraversal::value || allowStaticTraversal::value) { │ │ │ │ │ +132 Hybrid::forEach(indices, [&](auto i) { │ │ │ │ │ +133 auto&& _c_h_i_l_d = tree.child(i); │ │ │ │ │ +134 using _C_h_i_l_d = std::decay_t; │ │ │ │ │ +135 │ │ │ │ │ +136 visitor.beforeChild(tree, _c_h_i_l_d, _t_r_e_e_P_a_t_h, i); │ │ │ │ │ +137 │ │ │ │ │ +138 // This requires that visitor.in(...) can always be instantiated, │ │ │ │ │ +139 // even if there's a single child only. │ │ │ │ │ +140 if (i>0) │ │ │ │ │ +141 visitor.in(tree, _t_r_e_e_P_a_t_h); │ │ │ │ │ +142 │ │ │ │ │ +143 constexpr bool visitChild = Visitor::template │ │ │ │ │ +VisitChild::value; │ │ │ │ │ +144 if constexpr(visitChild) { │ │ │ │ │ +145 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); │ │ │ │ │ +146 _a_p_p_l_y_T_o_T_r_e_e(_c_h_i_l_d, childTreePath, visitor); │ │ │ │ │ +147 } │ │ │ │ │ +148 │ │ │ │ │ +149 visitor.afterChild(tree, _c_h_i_l_d, _t_r_e_e_P_a_t_h, i); │ │ │ │ │ +150 }); │ │ │ │ │ +151 } │ │ │ │ │ +152 visitor.post(tree, _t_r_e_e_P_a_t_h); │ │ │ │ │ +153 } │ │ │ │ │ +154 │ │ │ │ │ +155 /* Traverse tree and visit each node. The signature is the same │ │ │ │ │ +156 * as for the public forEachNode function in Dune::Typtree, │ │ │ │ │ +157 * despite the additionally passed treePath argument. The path │ │ │ │ │ +158 * passed here is associated to the tree and the relative │ │ │ │ │ +159 * paths of the children (wrt. to tree) are appended to this. │ │ │ │ │ +160 * Hence the behavior of the public function is resembled │ │ │ │ │ +161 * by passing an empty treePath. │ │ │ │ │ +162 */ │ │ │ │ │ +163 template │ │ │ │ │ +_1_6_4 void _f_o_r_E_a_c_h_N_o_d_e(T&& tree, TreePath _t_r_e_e_P_a_t_h, PreFunc&& preFunc, LeafFunc&& │ │ │ │ │ +leafFunc, PostFunc&& postFunc) │ │ │ │ │ +165 { │ │ │ │ │ +166 using Tree = std::decay_t; │ │ │ │ │ +167 if constexpr(Tree::isLeaf) { │ │ │ │ │ +168 leafFunc(tree, _t_r_e_e_P_a_t_h); │ │ │ │ │ +169 } else { │ │ │ │ │ +170 preFunc(tree, _t_r_e_e_P_a_t_h); │ │ │ │ │ +171 │ │ │ │ │ +172 // check which type of traversal is supported by the tree, prefer dynamic │ │ │ │ │ +traversal │ │ │ │ │ +173 using allowDynamicTraversal = Dune::Std:: │ │ │ │ │ +is_detected; │ │ │ │ │ +174 using allowStaticTraversal = Dune::Std:: │ │ │ │ │ +is_detected; │ │ │ │ │ +175 │ │ │ │ │ +176 // the tree must support either dynamic or static traversal │ │ │ │ │ +177 static_assert(allowDynamicTraversal::value || allowStaticTraversal::value); │ │ │ │ │ +178 │ │ │ │ │ +179 if constexpr(allowDynamicTraversal::value) { │ │ │ │ │ +180 // Specialization for dynamic traversal │ │ │ │ │ +181 for (std::size_t i = 0; i < tree.degree(); ++i) { │ │ │ │ │ +182 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); │ │ │ │ │ +183 _f_o_r_E_a_c_h_N_o_d_e(tree.child(i), childTreePath, preFunc, leafFunc, postFunc); │ │ │ │ │ +184 } │ │ │ │ │ +185 } else if constexpr(allowStaticTraversal::value) { │ │ │ │ │ +186 // Specialization for static traversal │ │ │ │ │ +187 auto indices = std::make_index_sequence{}; │ │ │ │ │ +188 Hybrid::forEach(indices, [&](auto i) { │ │ │ │ │ +189 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); │ │ │ │ │ +190 _f_o_r_E_a_c_h_N_o_d_e(tree.child(i), childTreePath, preFunc, leafFunc, postFunc); │ │ │ │ │ +191 }); │ │ │ │ │ +192 } │ │ │ │ │ +193 postFunc(tree, _t_r_e_e_P_a_t_h); │ │ │ │ │ +194 } │ │ │ │ │ +195 } │ │ │ │ │ +196 │ │ │ │ │ +197 } // namespace Detail │ │ │ │ │ +198 │ │ │ │ │ +199 │ │ │ │ │ +200 / │ │ │ │ │ +/ │ │ │ │ │ +******************************************************************************** │ │ │ │ │ +201 // Public Interface │ │ │ │ │ +202 / │ │ │ │ │ +/ │ │ │ │ │ +******************************************************************************** │ │ │ │ │ +203 │ │ │ │ │ +217 template │ │ │ │ │ +_2_1_8 constexpr auto _l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e() │ │ │ │ │ +219 { │ │ │ │ │ +220 return Detail::leafTreePathTuple, pathType> │ │ │ │ │ +(_h_y_b_r_i_d_T_r_e_e_P_a_t_h()); │ │ │ │ │ +221 } │ │ │ │ │ +222 │ │ │ │ │ +224 │ │ │ │ │ +238 template │ │ │ │ │ +_2_3_9 void _a_p_p_l_y_T_o_T_r_e_e(Tree&& tree, Visitor&& visitor) │ │ │ │ │ +240 { │ │ │ │ │ +241 _D_e_t_a_i_l_:_:_a_p_p_l_y_T_o_T_r_e_e(tree, _h_y_b_r_i_d_T_r_e_e_P_a_t_h(), visitor); │ │ │ │ │ +242 } │ │ │ │ │ +243 │ │ │ │ │ +253 template │ │ │ │ │ +_2_5_4 void _f_o_r_E_a_c_h_N_o_d_e(Tree&& tree, NodeFunc&& nodeFunc) │ │ │ │ │ +255 { │ │ │ │ │ +256 _D_e_t_a_i_l_:_:_f_o_r_E_a_c_h_N_o_d_e(tree, _h_y_b_r_i_d_T_r_e_e_P_a_t_h(), nodeFunc, nodeFunc, NoOp{}); │ │ │ │ │ +257 } │ │ │ │ │ +258 │ │ │ │ │ +268 template │ │ │ │ │ +_2_6_9 void _f_o_r_E_a_c_h_L_e_a_f_N_o_d_e(Tree&& tree, LeafFunc&& leafFunc) │ │ │ │ │ +270 { │ │ │ │ │ +271 _D_e_t_a_i_l_:_:_f_o_r_E_a_c_h_N_o_d_e(tree, _h_y_b_r_i_d_T_r_e_e_P_a_t_h(), NoOp{}, leafFunc, NoOp{}); │ │ │ │ │ +272 } │ │ │ │ │ +273 │ │ │ │ │ +275 │ │ │ │ │ +276 } // namespace TypeTree │ │ │ │ │ +277} //namespace Dune │ │ │ │ │ +278 │ │ │ │ │ +279#endif // DUNE_TYPETREE_TRAVERSAL_HH │ │ │ │ │ _c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h │ │ │ │ │ _n_o_d_e_t_a_g_s_._h_h │ │ │ │ │ -_p_a_i_r_t_r_a_v_e_r_s_a_l_._h_h │ │ │ │ │ -_l_e_a_f_n_o_d_e_._h_h │ │ │ │ │ -_d_y_n_a_m_i_c_p_o_w_e_r_n_o_d_e_._h_h │ │ │ │ │ -_t_r_a_v_e_r_s_a_l_._h_h │ │ │ │ │ -_t_r_a_v_e_r_s_a_l_u_t_i_l_i_t_i_e_s_._h_h │ │ │ │ │ +_t_r_e_e_p_a_t_h_._h_h │ │ │ │ │ +_v_i_s_i_t_o_r_._h_h │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_o_r_E_a_c_h_N_o_d_e │ │ │ │ │ +void forEachNode(Tree &&tree, NodeFunc &&nodeFunc) │ │ │ │ │ +Traverse tree and visit each node. │ │ │ │ │ +DDeeffiinniittiioonn traversal.hh:254 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e │ │ │ │ │ +constexpr auto leafTreePathTuple() │ │ │ │ │ +Create tuple of tree paths to leafs. │ │ │ │ │ +DDeeffiinniittiioonn traversal.hh:218 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_o_r_E_a_c_h_L_e_a_f_N_o_d_e │ │ │ │ │ +void forEachLeafNode(Tree &&tree, LeafFunc &&leafFunc) │ │ │ │ │ +Traverse tree and visit each leaf node. │ │ │ │ │ +DDeeffiinniittiioonn traversal.hh:269 │ │ │ │ │ +_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_:_:_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_:_:_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 │ │ │ │ │ +_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_:_:_D_e_t_a_i_l_:_:_f_o_r_E_a_c_h_N_o_d_e │ │ │ │ │ +void forEachNode(T &&tree, TreePath treePath, PreFunc &&preFunc, LeafFunc │ │ │ │ │ +&&leafFunc, PostFunc &&postFunc) │ │ │ │ │ +DDeeffiinniittiioonn traversal.hh:164 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_D_y_n_a_m_i_c_T_r_a_v_e_r_s_a_l_C_o_n_c_e_p_t │ │ │ │ │ +decltype((std::declval< Tree >().degree(), std::declval< Tree >().child(0u))) │ │ │ │ │ +DynamicTraversalConcept │ │ │ │ │ +DDeeffiinniittiioonn traversal.hh:43 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_S_t_a_t_i_c_T_r_a_v_e_r_s_a_l_C_o_n_c_e_p_t │ │ │ │ │ +decltype((std::integral_constant< std::size_t, Tree::degree()>{})) │ │ │ │ │ +StaticTraversalConcept │ │ │ │ │ +DDeeffiinniittiioonn traversal.hh:49 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_a_p_p_l_y_T_o_T_r_e_e │ │ │ │ │ +void applyToTree(T &&tree, TreePath treePath, V &&visitor) │ │ │ │ │ +DDeeffiinniittiioonn traversal.hh:97 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e │ │ │ │ │ +constexpr auto leafTreePathTuple(Prefix prefix) │ │ │ │ │ +DDeeffiinniittiioonn traversal.hh:54 │ │ │ │ │ +_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/a00062.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: generictransformationdescriptors.hh File Reference │ │ │ │ +dune-typetree: treepath.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -71,56 +71,190 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ Classes | │ │ │ │ -Namespaces
    │ │ │ │ -
    generictransformationdescriptors.hh File Reference
    │ │ │ │ +Namespaces | │ │ │ │ +Typedefs | │ │ │ │ +Enumerations | │ │ │ │ +Functions
    │ │ │ │ +
    treepath.hh File Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ -
    #include <array>
    │ │ │ │ -#include <memory>
    │ │ │ │ -#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ -#include <dune/typetree/nodetags.hh>
    │ │ │ │ -#include <dune/typetree/powercompositenodetransformationtemplates.hh>
    │ │ │ │ -#include <dune/common/exceptions.hh>
    │ │ │ │ +
    #include <cstddef>
    │ │ │ │ +#include <cassert>
    │ │ │ │ +#include <iostream>
    │ │ │ │ +#include <type_traits>
    │ │ │ │ +#include <dune/common/documentation.hh>
    │ │ │ │ +#include <dune/common/version.hh>
    │ │ │ │ +#include <dune/common/typetraits.hh>
    │ │ │ │ +#include <dune/common/indices.hh>
    │ │ │ │ +#include <dune/common/hybridutilities.hh>
    │ │ │ │ +#include <dune/common/typelist.hh>
    │ │ │ │ +#include <dune/typetree/fixedcapacitystack.hh>
    │ │ │ │ +#include <dune/typetree/utility.hh>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  Dune::TypeTree::GenericLeafNodeTransformation< SourceNode, Transformation, TransformedNode >
    class  Dune::TypeTree::HybridTreePath< T >
     A hybrid version of TreePath that supports both compile time and run time indices. More...
     
    struct  Dune::TypeTree::TemplatizedGenericPowerNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate >
    struct  Dune::TypeTree::TreePathSize< HybridTreePath< index_constant< i >... > >
     
    struct  Dune::TypeTree::TemplatizedGenericPowerNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate >::result< TC >
    struct  Dune::TypeTree::TreePathPushBack< HybridTreePath< index_constant< i >... >, k >
     
    struct  Dune::TypeTree::GenericPowerNodeTransformation< SourceNode, Transformation, TransformedNode >
    struct  Dune::TypeTree::TreePathPushFront< HybridTreePath< index_constant< i >... >, k >
     
    struct  Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate >
    struct  Dune::TypeTree::TreePathBack< HybridTreePath< index_constant< k > > >
     
    struct  Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate >::result< TC >
    struct  Dune::TypeTree::TreePathBack< HybridTreePath< index_constant< j >, index_constant< k >, index_constant< l >... > >
     
    struct  Dune::TypeTree::GenericDynamicPowerNodeTransformation< SourceNode, Transformation, TransformedNode >
    struct  Dune::TypeTree::TreePathFront< HybridTreePath< index_constant< k >, index_constant< i >... > >
     
    struct  Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate >
    struct  Dune::TypeTree::TreePathPopBack< HybridTreePath< index_constant< k > >, i... >
     
    struct  Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate >::result< TC >
    struct  Dune::TypeTree::TreePathPopBack< HybridTreePath< index_constant< j >, index_constant< k >, index_constant< l >... >, i... >
     
    struct  Dune::TypeTree::GenericCompositeNodeTransformation< SourceNode, Transformation, TransformedNode >
    struct  Dune::TypeTree::TreePathPopFront< HybridTreePath< index_constant< k >, index_constant< i >... > >
     
    struct  Dune::TypeTree::TreePathConcat< HybridTreePath< index_constant< i >... >, HybridTreePath< index_constant< k >... > >
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
     
    namespace  Dune::TypeTree::TreePathType
     
    namespace  Dune::TypeTree::Literals
     
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +

    │ │ │ │ +Typedefs

    template<std::size_t... i>
    using Dune::TypeTree::StaticTreePath = HybridTreePath< Dune::index_constant< i >... >
     
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +

    │ │ │ │ +Enumerations

    enum  Dune::TypeTree::TreePathType::Type { Dune::TypeTree::TreePathType::fullyStatic │ │ │ │ +, Dune::TypeTree::TreePathType::dynamic │ │ │ │ + }
     
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │

    │ │ │ │ +Functions

    template<std::size_t... i>
    void Dune::TypeTree::print_tree_path (std::ostream &os)
     
    template<std::size_t k, std::size_t... i>
    void Dune::TypeTree::print_tree_path (std::ostream &os)
     
    template<typename... T>
    constexpr auto Dune::TypeTree::makeTreePath (const T... t)
     helper function to construct a new HybridTreePath from the given indices.
     
    template<typename... T>
    constexpr auto Dune::TypeTree::hybridTreePath (const T &... t)
     Constructs a new HybridTreePath from the given indices.
     
    template<typename... T>
    constexpr auto Dune::TypeTree::treePath (const T &... t)
     Constructs a new HybridTreePath from the given indices.
     
    template<typename... T>
    constexpr std::size_t Dune::TypeTree::treePathSize (const HybridTreePath< T... > &)
     Returns the size (number of components) of the given HybridTreePath.
     
    template<std::size_t i, typename... T>
    constexpr auto Dune::TypeTree::treePathEntry (const HybridTreePath< T... > &tp, index_constant< i >={}) -> typename std::decay< decltype(std::get< i >(tp._data))>::type
     Returns a copy of the i-th element of the HybridTreePath.
     
    template<std::size_t i, typename... T>
    constexpr std::size_t Dune::TypeTree::treePathIndex (const HybridTreePath< T... > &tp, index_constant< i >={})
     Returns the index value of the i-th element of the HybridTreePath.
     
    template<typename... T>
    constexpr auto Dune::TypeTree::back (const HybridTreePath< T... > &tp) -> decltype(tp.back())
     Returns a copy of the last element of the HybridTreePath.
     
    template<typename... T>
    constexpr auto Dune::TypeTree::front (const HybridTreePath< T... > &tp) -> decltype(tp.front())
     Returns a copy of the first element of the HybridTreePath.
     
    template<typename... T>
    constexpr HybridTreePath< T..., std::size_t > Dune::TypeTree::push_back (const HybridTreePath< T... > &tp, std::size_t i)
     Appends a run time index to a HybridTreePath.
     
    template<std::size_t i, typename... T>
    constexpr HybridTreePath< T..., index_constant< i > > Dune::TypeTree::push_back (const HybridTreePath< T... > &tp, index_constant< i > i_={})
     Appends a compile time index to a HybridTreePath.
     
    template<typename... T>
    constexpr HybridTreePath< std::size_t, T... > Dune::TypeTree::push_front (const HybridTreePath< T... > &tp, std::size_t element)
     Prepends a run time index to a HybridTreePath.
     
    template<std::size_t i, typename... T>
    constexpr HybridTreePath< index_constant< i >, T... > Dune::TypeTree::push_front (const HybridTreePath< T... > &tp, index_constant< i > _i={})
     Prepends a compile time index to a HybridTreePath.
     
    template<typename I , typename... T, std::enable_if_t<(sizeof...(T) > 0), bool > = true>
    constexpr auto Dune::TypeTree::accumulate_back (const HybridTreePath< T... > &tp, I i)
     Hybrid utility that accumulates to the back of a multi-index.
     
    template<typename I , typename... T, std::enable_if_t<(sizeof...(T) > 0), bool > = true>
    constexpr auto Dune::TypeTree::accumulate_front (const HybridTreePath< T... > &tp, I i)
     Hybrid utility that accumulates to the front of a multi-index.
     
    template<class... Head, class... Other>
    constexpr auto Dune::TypeTree::join (const HybridTreePath< Head... > &head, const Other &... tail)
     Join two tree paths into one.
     
    template<class... T>
    constexpr auto Dune::TypeTree::reverse (const HybridTreePath< T... > &tp)
     Reverses the order of the elements in the path.
     
    template<class... T, std::enable_if_t<(sizeof...(T) > 0), bool > = true>
    constexpr auto Dune::TypeTree::pop_front (const HybridTreePath< T... > &tp)
     Removes first index on a HybridTreePath.
     
    template<class... T, std::enable_if_t<(sizeof...(T) > 0), bool > = true>
    constexpr auto Dune::TypeTree::pop_back (const HybridTreePath< T... > &tp)
     Removes last index on a HybridTreePath.
     
    template<class... S, class... T>
    constexpr bool Dune::TypeTree::operator== (const HybridTreePath< S... > &lhs, const HybridTreePath< T... > &rhs)
     Compare two HybridTreePaths for value equality.
     
    template<class S , S... lhs, class T , T... rhs>
    constexpr auto Dune::TypeTree::operator== (const HybridTreePath< std::integral_constant< S, lhs >... > &, const HybridTreePath< std::integral_constant< T, rhs >... > &)
     Overload for purely static HybridTreePaths.
     
    template<class... S, class... T>
    constexpr auto Dune::TypeTree::operator!= (const HybridTreePath< S... > &lhs, const HybridTreePath< T... > &rhs)
     Compare two HybridTreePaths for unequality.
     
    template<class S , S... lhs, class T , T... rhs>
    constexpr auto Dune::TypeTree::operator!= (const HybridTreePath< std::integral_constant< S, lhs >... > &, const HybridTreePath< std::integral_constant< T, rhs >... > &)
     Compare two static HybridTreePaths for unequality.
     
    template<char... digits>
    constexpr auto Dune::TypeTree::Literals::operator""_tp ()
     Literal to create treepath.
     
    template<typename... T>
    std::ostream & Dune::TypeTree::operator<< (std::ostream &os, const HybridTreePath< T... > &tp)
     Dumps a HybridTreePath to a stream.
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,53 +1,242 @@ │ │ │ │ │ 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 │ │ │ │ │ -generictransformationdescriptors.hh File Reference │ │ │ │ │ -#include │ │ │ │ │ -#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_/_p_o_w_e_r_c_o_m_p_o_s_i_t_e_n_o_d_e_t_r_a_n_s_f_o_r_m_a_t_i_o_n_t_e_m_p_l_a_t_e_s_._h_h> │ │ │ │ │ -#include │ │ │ │ │ +_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s | _T_y_p_e_d_e_f_s | _E_n_u_m_e_r_a_t_i_o_n_s | _F_u_n_c_t_i_o_n_s │ │ │ │ │ +treepath.hh File Reference │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_f_i_x_e_d_c_a_p_a_c_i_t_y_s_t_a_c_k_._h_h> │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_u_t_i_l_i_t_y_._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_:_:_G_e_n_e_r_i_c_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ - _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ + class   _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_<_ _T_ _> │ │ │ │ │ +  A hybrid version of TreePath that supports both compile time and run │ │ │ │ │ + time indices. _M_o_r_e_._._. │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ - _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_T_e_m_p_l_a_t_e_ _> │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_S_i_z_e_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i_ _>_._._._ _> │ │ │ │ │ + _> │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ - _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_T_e_m_p_l_a_t_e_ _>_:_:_r_e_s_u_l_t_<_ _T_C_ _> │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_u_s_h_B_a_c_k_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i │ │ │ │ │ + _>_._._._ _>_,_ _k_ _> │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ - _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_u_s_h_F_r_o_n_t_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i │ │ │ │ │ + _>_._._._ _>_,_ _k_ _> │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_< │ │ │ │ │ - _S_o_u_r_c_e_N_o_d_e_,_ _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_T_e_m_p_l_a_t_e_ _> │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_B_a_c_k_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _>_ _>_ _> │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_< │ │ │ │ │ - _S_o_u_r_c_e_N_o_d_e_,_ _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_T_e_m_p_l_a_t_e_ _>_:_:_r_e_s_u_l_t_<_ _T_C_ _> │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_B_a_c_k_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _j_ _>_, │ │ │ │ │ + _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _>_,_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _l_ _>_._._._ _>_ _> │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ - _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_F_r_o_n_t_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _>_, │ │ │ │ │ + _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i_ _>_._._._ _>_ _> │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_< │ │ │ │ │ - _S_o_u_r_c_e_N_o_d_e_,_ _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_T_e_m_p_l_a_t_e_ _> │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_o_p_B_a_c_k_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _> │ │ │ │ │ + _>_,_ _i_._._._ _> │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_< │ │ │ │ │ - _S_o_u_r_c_e_N_o_d_e_,_ _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_T_e_m_p_l_a_t_e_ _>_:_:_r_e_s_u_l_t_<_ _T_C_ _> │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_o_p_B_a_c_k_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _j_ _>_, │ │ │ │ │ + _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _>_,_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _l_ _>_._._._ _>_,_ _i_._._._ _> │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ - _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_o_p_F_r_o_n_t_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _>_, │ │ │ │ │ + _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i_ _>_._._._ _>_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_C_o_n_c_a_t_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i_ _>_._._. │ │ │ │ │ + _>_,_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _>_._._._ _>_ _> │ │ │ │ │   │ │ │ │ │ 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_:_:_T_r_e_e_P_a_t_h_T_y_p_e │ │ │ │ │ +  │ │ │ │ │ +namespace   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_i_t_e_r_a_l_s │ │ │ │ │ +  │ │ │ │ │ +TTyyppeeddeeffss │ │ │ │ │ +template │ │ │ │ │ +using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_T_r_e_e_P_a_t_h = _H_y_b_r_i_d_T_r_e_e_P_a_t_h< Dune::index_constant< i │ │ │ │ │ + >... > │ │ │ │ │ +  │ │ │ │ │ +EEnnuummeerraattiioonnss │ │ │ │ │ +enum   _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 { _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_T_y_p_e_:_: │ │ │ │ │ + _f_u_l_l_y_S_t_a_t_i_c , _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 } │ │ │ │ │ +  │ │ │ │ │ +FFuunnccttiioonnss │ │ │ │ │ +template │ │ │ │ │ + void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_r_i_n_t___t_r_e_e___p_a_t_h (std:: │ │ │ │ │ + ostream &os) │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_r_i_n_t___t_r_e_e___p_a_t_h (std:: │ │ │ │ │ + ostream &os) │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_a_k_e_T_r_e_e_P_a_t_h (const T... │ │ │ │ │ + t) │ │ │ │ │ +  helper function to construct a new │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h from the given indices. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + constexpr auto  _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 (const T │ │ │ │ │ + &... t) │ │ │ │ │ +  Constructs a new _H_y_b_r_i_d_T_r_e_e_P_a_t_h from the │ │ │ │ │ + given indices. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_t_r_e_e_P_a_t_h (const T &... │ │ │ │ │ + t) │ │ │ │ │ +  Constructs a new _H_y_b_r_i_d_T_r_e_e_P_a_t_h from the │ │ │ │ │ + given indices. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + constexpr std::size_t  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_t_r_e_e_P_a_t_h_S_i_z_e (const │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &) │ │ │ │ │ +  Returns the size (number of components) │ │ │ │ │ + of the given _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_t_r_e_e_P_a_t_h_E_n_t_r_y (const │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp, │ │ │ │ │ + index_constant< i >={}) -> typename │ │ │ │ │ + std::decay< decltype(std::get< i > │ │ │ │ │ + (tp._data))>::type │ │ │ │ │ +  Returns a copy of the i-th element of │ │ │ │ │ + the _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + constexpr std::size_t  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_t_r_e_e_P_a_t_h_I_n_d_e_x (const │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp, │ │ │ │ │ + index_constant< i >={}) │ │ │ │ │ +  Returns the index value of the i-th │ │ │ │ │ + element of the _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_b_a_c_k (const │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp) -> decltype │ │ │ │ │ + (tp.back()) │ │ │ │ │ +  Returns a copy of the last element of │ │ │ │ │ + the _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_r_o_n_t (const │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp) -> decltype │ │ │ │ │ + (tp.front()) │ │ │ │ │ +  Returns a copy of the first element of │ │ │ │ │ + the _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T..., std:: _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_u_s_h___b_a_c_k (const │ │ │ │ │ + size_t >  _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp, std::size_t │ │ │ │ │ + i) │ │ │ │ │ +  Appends a run time index to a │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T..., _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_u_s_h___b_a_c_k (const │ │ │ │ │ + index_constant< i > >  _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp, │ │ │ │ │ + index_constant< i > i_={}) │ │ │ │ │ +  Appends a compile time index to a │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ +constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h< std::size_t, _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_u_s_h___f_r_o_n_t (const │ │ │ │ │ + T... >  _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp, std::size_t │ │ │ │ │ + element) │ │ │ │ │ +  Prepends a run time index to a │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h< _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_u_s_h___f_r_o_n_t (const │ │ │ │ │ + index_constant< i >, T... >  _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp, │ │ │ │ │ + index_constant< i > _i={}) │ │ │ │ │ +  Prepends a compile time index to a │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ +  │ │ │ │ │ +template 0), bool │ │ │ │ │ +> = true> │ │ │ │ │ + constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_c_c_u_m_u_l_a_t_e___b_a_c_k (const │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp, I i) │ │ │ │ │ +  Hybrid utility that accumulates to the │ │ │ │ │ + back of a multi-index. │ │ │ │ │ +  │ │ │ │ │ +template 0), bool │ │ │ │ │ +> = true> │ │ │ │ │ + constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_c_c_u_m_u_l_a_t_e___f_r_o_n_t (const │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp, I i) │ │ │ │ │ +  Hybrid utility that accumulates to the │ │ │ │ │ + front of a multi-index. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_j_o_i_n (const │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h< Head... > &head, const │ │ │ │ │ + Other &... tail) │ │ │ │ │ +  Join two tree paths into one. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_r_e_v_e_r_s_e (const │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp) │ │ │ │ │ +  Reverses the order of the elements in │ │ │ │ │ + the path. │ │ │ │ │ +  │ │ │ │ │ +template 0), bool > = true> │ │ │ │ │ + constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_o_p___f_r_o_n_t (const │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp) │ │ │ │ │ +  Removes first index on a _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ +  │ │ │ │ │ +template 0), bool > = true> │ │ │ │ │ + constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_o_p___b_a_c_k (const │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp) │ │ │ │ │ +  Removes last index on a _H_y_b_r_i_d_T_r_e_e_P_a_t_h. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + constexpr bool  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_p_e_r_a_t_o_r_=_= (const │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h< S... > &lhs, const │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &rhs) │ │ │ │ │ +  Compare two _H_y_b_r_i_d_T_r_e_e_P_a_t_hs for value │ │ │ │ │ + equality. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_p_e_r_a_t_o_r_=_= (const │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h< std::integral_constant< │ │ │ │ │ + S, lhs >... > &, const _H_y_b_r_i_d_T_r_e_e_P_a_t_h< │ │ │ │ │ + std::integral_constant< T, rhs >... > &) │ │ │ │ │ +  Overload for purely static │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_hs. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_p_e_r_a_t_o_r_!_= (const │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h< S... > &lhs, const │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &rhs) │ │ │ │ │ +  Compare two _H_y_b_r_i_d_T_r_e_e_P_a_t_hs for │ │ │ │ │ + unequality. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_p_e_r_a_t_o_r_!_= (const │ │ │ │ │ + _H_y_b_r_i_d_T_r_e_e_P_a_t_h< std::integral_constant< │ │ │ │ │ + S, lhs >... > &, const _H_y_b_r_i_d_T_r_e_e_P_a_t_h< │ │ │ │ │ + std::integral_constant< T, rhs >... > &) │ │ │ │ │ +  Compare two static _H_y_b_r_i_d_T_r_e_e_P_a_t_hs for │ │ │ │ │ + unequality. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_i_t_e_r_a_l_s_:_:_o_p_e_r_a_t_o_r_"_"___t_p │ │ │ │ │ + () │ │ │ │ │ +  Literal to create treepath. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ + std::ostream &  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_p_e_r_a_t_o_r_<_< (std::ostream │ │ │ │ │ + &os, const _H_y_b_r_i_d_T_r_e_e_P_a_t_h< T... > &tp) │ │ │ │ │ +  Dumps a _H_y_b_r_i_d_T_r_e_e_P_a_t_h to a stream. │ │ │ │ │ +  │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00062_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: generictransformationdescriptors.hh Source File │ │ │ │ +dune-typetree: treepath.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,288 +74,734 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -
    generictransformationdescriptors.hh
    │ │ │ │ +
    treepath.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ -Go to the documentation of this file.
    1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
    │ │ │ │ -
    2// vi: set et ts=4 sw=2 sts=2:
    │ │ │ │ +Go to the documentation of this file.
    1// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
    │ │ │ │ +
    2// vi: set et ts=8 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_GENERICTRANSFORMATIONDESCRIPTORS_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_GENERICTRANSFORMATIONDESCRIPTORS_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_TREEPATH_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_TREEPATH_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <array>
    │ │ │ │ -
    10#include <memory>
    │ │ │ │ -
    11
    │ │ │ │ -
    12#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ -
    13#include <dune/typetree/nodetags.hh>
    │ │ │ │ -
    14#include <dune/typetree/powercompositenodetransformationtemplates.hh>
    │ │ │ │ -
    15#include <dune/common/exceptions.hh>
    │ │ │ │ -
    16
    │ │ │ │ -
    17
    │ │ │ │ -
    18namespace Dune {
    │ │ │ │ -
    19 namespace TypeTree {
    │ │ │ │ +
    9#include <cstddef>
    │ │ │ │ +
    10#include <cassert>
    │ │ │ │ +
    11#include <iostream>
    │ │ │ │ +
    12#include <type_traits>
    │ │ │ │ +
    13
    │ │ │ │ +
    14#include <dune/common/documentation.hh>
    │ │ │ │ +
    15#include <dune/common/version.hh>
    │ │ │ │ +
    16#include <dune/common/typetraits.hh>
    │ │ │ │ +
    17#include <dune/common/indices.hh>
    │ │ │ │ +
    18#include <dune/common/hybridutilities.hh>
    │ │ │ │ +
    19#include <dune/common/typelist.hh>
    │ │ │ │
    20
    │ │ │ │ -
    26 template<typename SourceNode, typename Transformation, typename TransformedNode>
    │ │ │ │ -
    │ │ │ │ -
    27 struct GenericLeafNodeTransformation
    │ │ │ │ -
    28 {
    │ │ │ │ -
    29
    │ │ │ │ -
    30 static const bool recursive = false;
    │ │ │ │ -
    31
    │ │ │ │ -
    32 typedef TransformedNode transformed_type;
    │ │ │ │ -
    33 typedef std::shared_ptr<transformed_type> transformed_storage_type;
    │ │ │ │ -
    34
    │ │ │ │ -
    │ │ │ │ -
    35 static transformed_type transform(const SourceNode& s, const Transformation& t)
    │ │ │ │ -
    36 {
    │ │ │ │ -
    37 return transformed_type(s,t);
    │ │ │ │ -
    38 }
    │ │ │ │ -
    │ │ │ │ -
    39
    │ │ │ │ -
    │ │ │ │ -
    40 static transformed_type transform(std::shared_ptr<const SourceNode> s, const Transformation& t)
    │ │ │ │ -
    41 {
    │ │ │ │ -
    42 return transformed_type(s,t);
    │ │ │ │ -
    43 }
    │ │ │ │ -
    │ │ │ │ +
    21#include <dune/typetree/fixedcapacitystack.hh>
    │ │ │ │ +
    22#include <dune/typetree/utility.hh>
    │ │ │ │ +
    23
    │ │ │ │ +
    24namespace Dune {
    │ │ │ │ +
    25 namespace TypeTree {
    │ │ │ │ +
    26
    │ │ │ │ +
    27 // The Impl namespace collects some free standing functions helper functions
    │ │ │ │ +
    28 namespace Impl {
    │ │ │ │ +
    29 template<typename T>
    │ │ │ │ +
    30 struct check_size_t_impl
    │ │ │ │ +
    31 {
    │ │ │ │ +
    32 static constexpr auto check() {
    │ │ │ │ +
    33 return std::is_same_v<T, std::size_t>;
    │ │ │ │ +
    34 }
    │ │ │ │ +
    35 };
    │ │ │ │ +
    36
    │ │ │ │ +
    37 template<class T, T v>
    │ │ │ │ +
    38 struct check_size_t_impl<std::integral_constant<T,v>>
    │ │ │ │ +
    39 {
    │ │ │ │ +
    40 static constexpr auto check() {
    │ │ │ │ +
    41 return std::is_same_v<T, std::size_t>;
    │ │ │ │ +
    42 }
    │ │ │ │ +
    43 };
    │ │ │ │
    44
    │ │ │ │ -
    │ │ │ │ -
    45 static transformed_storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t)
    │ │ │ │ -
    46 {
    │ │ │ │ -
    47 return std::make_shared<transformed_type>(s,t);
    │ │ │ │ +
    45 template<typename T>
    │ │ │ │ +
    46 constexpr auto check_size_t() {
    │ │ │ │ +
    47 return check_size_t_impl<T>::check();
    │ │ │ │
    48 }
    │ │ │ │ -
    │ │ │ │
    49
    │ │ │ │ -
    50 };
    │ │ │ │ -
    │ │ │ │ -
    51
    │ │ │ │ -
    52
    │ │ │ │ -
    53 template<typename SourceNode, typename Transformation, template<typename Child> class TransformedNodeTemplate>
    │ │ │ │ -
    │ │ │ │ -
    54 struct TemplatizedGenericPowerNodeTransformation
    │ │ │ │ -
    55 {
    │ │ │ │ -
    56
    │ │ │ │ -
    57 static const bool recursive = true;
    │ │ │ │ -
    58
    │ │ │ │ -
    59 template<typename TC>
    │ │ │ │ -
    │ │ │ │ -
    60 struct result
    │ │ │ │ -
    61 {
    │ │ │ │ -
    62 typedef typename TransformedNodeTemplate<TC>::type type;
    │ │ │ │ -
    63 typedef std::shared_ptr<type> storage_type;
    │ │ │ │ -
    64 static const std::size_t degree = StaticDegree<type>::value;
    │ │ │ │ -
    65 };
    │ │ │ │ -
    │ │ │ │ -
    66
    │ │ │ │ -
    67 template<typename TC>
    │ │ │ │ -
    │ │ │ │ -
    68 static typename result<TC>::type transform(const SourceNode& s, const Transformation& t, const std::array<std::shared_ptr<TC>,result<TC>::degree>& children)
    │ │ │ │ -
    69 {
    │ │ │ │ -
    70 return typename result<TC>::type(s,t,children);
    │ │ │ │ -
    71 }
    │ │ │ │ -
    │ │ │ │ -
    72
    │ │ │ │ -
    73 template<typename TC>
    │ │ │ │ -
    │ │ │ │ -
    74 static typename result<TC>::type transform(std::shared_ptr<const SourceNode> s, const Transformation& t, const std::array<std::shared_ptr<TC>,result<TC>::degree>& children)
    │ │ │ │ -
    75 {
    │ │ │ │ -
    76 return typename result<TC>::type(s,t,children);
    │ │ │ │ -
    77 }
    │ │ │ │ -
    │ │ │ │ -
    78
    │ │ │ │ -
    79 template<typename TC>
    │ │ │ │ -
    │ │ │ │ -
    80 static typename result<TC>::storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t, const std::array<std::shared_ptr<TC>,result<TC>::degree>& children)
    │ │ │ │ -
    81 {
    │ │ │ │ -
    82 return std::make_shared<typename result<TC>::type>(s,t,children);
    │ │ │ │ -
    83 }
    │ │ │ │ -
    │ │ │ │ -
    84
    │ │ │ │ -
    85 };
    │ │ │ │ -
    │ │ │ │ -
    86
    │ │ │ │ -
    87
    │ │ │ │ -
    88 template<typename SourceNode, typename Transformation, template<typename,typename,std::size_t> class TransformedNode>
    │ │ │ │ -
    │ │ │ │ -
    89 struct GenericPowerNodeTransformation
    │ │ │ │ -
    90 : public TemplatizedGenericPowerNodeTransformation<SourceNode,
    │ │ │ │ -
    91 Transformation,
    │ │ │ │ -
    92 GenericPowerNodeTransformationTemplate<SourceNode,
    │ │ │ │ -
    93 Transformation,
    │ │ │ │ -
    94 TransformedNode>::template result
    │ │ │ │ -
    95 >
    │ │ │ │ -
    96 {};
    │ │ │ │ -
    │ │ │ │ +
    50 template<typename T>
    │ │ │ │ +
    51 constexpr auto cast_size_t(const T & v) {
    │ │ │ │ +
    52 // check that T is an integral type that can be cast to std::size_t
    │ │ │ │ +
    53 static_assert(
    │ │ │ │ +
    54 std::is_convertible_v<T,std::size_t> &&
    │ │ │ │ +
    55 std::is_integral_v<T>,
    │ │ │ │ +
    56 "HybridTreePath indices must be convertible to std::size_t or std::integral_constant<std::size_t,v>");
    │ │ │ │ +
    57 // positivity can only be checked at run-time
    │ │ │ │ +
    58 assert(v >= 0 &&
    │ │ │ │ +
    59 "HybridTreePath indices must be convertible to std::size_t or std::integral_constant<std::size_t,v>");
    │ │ │ │ +
    60 return std::size_t(v);
    │ │ │ │ +
    61 }
    │ │ │ │ +
    62
    │ │ │ │ +
    63 template<class T, T v>
    │ │ │ │ +
    64 constexpr auto cast_size_t(std::integral_constant<T,v>) {
    │ │ │ │ +
    65 // check that T is an intergal type that can be cast to std::size_t
    │ │ │ │ +
    66 // and that v is positive
    │ │ │ │ +
    67 static_assert(
    │ │ │ │ +
    68 std::is_convertible_v<T,std::size_t> &&
    │ │ │ │ +
    69 std::is_integral_v<T> &&
    │ │ │ │ +
    70 v >= 0,
    │ │ │ │ +
    71 "HybridTreePath indices must be convertible to std::size_t or std::integral_constant<std::size_t,v>");
    │ │ │ │ +
    72 return std::integral_constant<std::size_t,v>();
    │ │ │ │ +
    73 }
    │ │ │ │ +
    74
    │ │ │ │ +
    75 // these are helper functions that help triggering a deprecation warning
    │ │ │ │ +
    76 template<typename T>
    │ │ │ │ +
    77 [[deprecated("HybridTreePath index storage should be std::size_t or std::integral_constant<std::size_t,v>!\n"
    │ │ │ │ +
    78 "Using anything else is deprecated and will not possible after the 2.10 release.\n"
    │ │ │ │ +
    79 "It is adviced not to specify the template parameters expicitly,\n"
    │ │ │ │ +
    80 "but to use the helper functions `hybridTreePath` or `treePath`."
    │ │ │ │ +
    81 "These take care of converting indices to the appropriate storage.")]]
    │ │ │ │ +
    82 constexpr bool check_storage_type(MetaType<T>) {
    │ │ │ │ +
    83 return false;
    │ │ │ │ +
    84 }
    │ │ │ │ +
    85
    │ │ │ │ +
    86 // specialization of valid index type
    │ │ │ │ +
    87 template<std::size_t v>
    │ │ │ │ +
    88 constexpr bool check_storage_type(MetaType<std::integral_constant<std::size_t,v>>) {
    │ │ │ │ +
    89 return true;
    │ │ │ │ +
    90 }
    │ │ │ │ +
    91
    │ │ │ │ +
    92 // specialization of valid index type
    │ │ │ │ +
    93 constexpr bool check_storage_type(MetaType<std::size_t>) {
    │ │ │ │ +
    94 return true;
    │ │ │ │ +
    95 }
    │ │ │ │ +
    96 }
    │ │ │ │
    97
    │ │ │ │ -
    98
    │ │ │ │ -
    99 template<typename SourceNode, typename Transformation, template<typename Child> class TransformedNodeTemplate>
    │ │ │ │ -
    │ │ │ │ -
    100 struct TemplatizedGenericDynamicPowerNodeTransformation
    │ │ │ │ -
    101 {
    │ │ │ │ -
    102
    │ │ │ │ -
    103 static const bool recursive = true;
    │ │ │ │ +
    98 template<typename... T>
    │ │ │ │ +
    99 class HybridTreePath;
    │ │ │ │ +
    100
    │ │ │ │
    104
    │ │ │ │ -
    105 template<typename TC>
    │ │ │ │ -
    │ │ │ │ -
    106 struct result
    │ │ │ │ -
    107 {
    │ │ │ │ -
    108 typedef typename TransformedNodeTemplate<TC>::type type;
    │ │ │ │ -
    109 typedef std::shared_ptr<type> storage_type;
    │ │ │ │ -
    110 };
    │ │ │ │ -
    │ │ │ │ +
    │ │ │ │ +
    105 namespace TreePathType {
    │ │ │ │ +
    106 enum Type { fullyStatic, dynamic };
    │ │ │ │ +
    107 }
    │ │ │ │ +
    │ │ │ │ +
    108
    │ │ │ │ +
    109 template<typename>
    │ │ │ │ +
    110 struct TreePathSize;
    │ │ │ │
    111
    │ │ │ │ -
    112 template<typename TC>
    │ │ │ │ -
    │ │ │ │ -
    113 static typename result<TC>::type transform(const SourceNode& s, const Transformation& t, const std::vector<std::shared_ptr<TC>>& children)
    │ │ │ │ -
    114 {
    │ │ │ │ -
    115 return typename result<TC>::type(s,t,children);
    │ │ │ │ -
    116 }
    │ │ │ │ -
    │ │ │ │ +
    112 template<typename,std::size_t>
    │ │ │ │ +
    113 struct TreePathPushBack;
    │ │ │ │ +
    114
    │ │ │ │ +
    115 template<typename,std::size_t>
    │ │ │ │ +
    116 struct TreePathPushFront;
    │ │ │ │
    117
    │ │ │ │ -
    118 template<typename TC>
    │ │ │ │ -
    │ │ │ │ -
    119 static typename result<TC>::type transform(std::shared_ptr<const SourceNode> s, const Transformation& t, const std::vector<std::shared_ptr<TC>>& children)
    │ │ │ │ -
    120 {
    │ │ │ │ -
    121 return typename result<TC>::type(s,t,children);
    │ │ │ │ -
    122 }
    │ │ │ │ -
    │ │ │ │ +
    118 template<typename>
    │ │ │ │ +
    119 struct TreePathBack;
    │ │ │ │ +
    120
    │ │ │ │ +
    121 template<typename>
    │ │ │ │ +
    122 struct TreePathFront;
    │ │ │ │
    123
    │ │ │ │ -
    124 template<typename TC>
    │ │ │ │ -
    │ │ │ │ -
    125 static typename result<TC>::storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t, const std::vector<std::shared_ptr<TC>>& children)
    │ │ │ │ -
    126 {
    │ │ │ │ -
    127 return std::make_shared<typename result<TC>::type>(s,t,children);
    │ │ │ │ -
    128 }
    │ │ │ │ -
    │ │ │ │ +
    124 template<typename, std::size_t...>
    │ │ │ │ +
    125 struct TreePathPopBack;
    │ │ │ │ +
    126
    │ │ │ │ +
    127 template<typename>
    │ │ │ │ +
    128 struct TreePathPopFront;
    │ │ │ │
    129
    │ │ │ │ -
    130 };
    │ │ │ │ -
    │ │ │ │ -
    131
    │ │ │ │ +
    130 template<typename, typename>
    │ │ │ │ +
    131 struct TreePathConcat;
    │ │ │ │
    132
    │ │ │ │ -
    133 template<typename SourceNode, typename Transformation, template<typename,typename> class TransformedNode>
    │ │ │ │ -
    │ │ │ │ -
    134 struct GenericDynamicPowerNodeTransformation
    │ │ │ │ -
    135 : public TemplatizedGenericDynamicPowerNodeTransformation<SourceNode,
    │ │ │ │ -
    136 Transformation,
    │ │ │ │ -
    137 GenericDynamicPowerNodeTransformationTemplate<SourceNode,
    │ │ │ │ -
    138 Transformation,
    │ │ │ │ -
    139 TransformedNode>::template result
    │ │ │ │ -
    140 >
    │ │ │ │ -
    141 {};
    │ │ │ │ +
    133 template<std::size_t... i>
    │ │ │ │ +
    │ │ │ │ +
    134 void print_tree_path(std::ostream& os)
    │ │ │ │ +
    135 {}
    │ │ │ │ +
    │ │ │ │ +
    136
    │ │ │ │ +
    137 template<std::size_t k, std::size_t... i>
    │ │ │ │ +
    │ │ │ │ +
    138 void print_tree_path(std::ostream& os)
    │ │ │ │ +
    139 {
    │ │ │ │ +
    140 os << k << " ";
    │ │ │ │ +
    141 print_tree_path<i...>(os);
    │ │ │ │ +
    142 }
    │ │ │ │
    │ │ │ │ -
    142
    │ │ │ │
    143
    │ │ │ │ -
    144 template<typename SourceNode, typename Transformation, template<typename...> class TransformedNodeTemplate>
    │ │ │ │ -
    │ │ │ │ -
    145 struct TemplatizedGenericCompositeNodeTransformation
    │ │ │ │ -
    146 {
    │ │ │ │ -
    147
    │ │ │ │ -
    148 static const bool recursive = true;
    │ │ │ │ -
    149
    │ │ │ │ -
    150 template<typename... TC>
    │ │ │ │ -
    │ │ │ │ -
    151 struct result
    │ │ │ │ -
    152 {
    │ │ │ │ -
    153 typedef typename TransformedNodeTemplate<TC...>::type type;
    │ │ │ │ -
    154 typedef std::shared_ptr<type> storage_type;
    │ │ │ │ -
    155 };
    │ │ │ │ -
    │ │ │ │ -
    156
    │ │ │ │ -
    157 template<typename... TC>
    │ │ │ │ -
    │ │ │ │ -
    158 static typename result<TC...>::type transform(const SourceNode& s, const Transformation& t, std::shared_ptr<TC>... children)
    │ │ │ │ -
    159 {
    │ │ │ │ -
    160 return typename result<TC...>::type(s,t,children...);
    │ │ │ │ -
    161 }
    │ │ │ │ -
    │ │ │ │ -
    162
    │ │ │ │ -
    163 template<typename... TC>
    │ │ │ │ -
    │ │ │ │ -
    164 static typename result<TC...>::type transform(std::shared_ptr<const SourceNode> s, const Transformation& t, std::shared_ptr<TC>... children)
    │ │ │ │ -
    165 {
    │ │ │ │ -
    166 return typename result<TC...>::type(s,t,children...);
    │ │ │ │ -
    167 }
    │ │ │ │ -
    │ │ │ │ +
    145
    │ │ │ │ +
    156 template<typename... T>
    │ │ │ │ +
    │ │ │ │ +
    157 class HybridTreePath
    │ │ │ │ +
    158 {
    │ │ │ │ +
    159
    │ │ │ │ +
    160 // enable check for dune-typetree 2.10 and above
    │ │ │ │ +
    161#if DUNE_VERSION_GTE(TYPETREE,2,10)
    │ │ │ │ +
    162 // make sure that all indices use std::size_t as the underlying number type
    │ │ │ │ +
    163 static_assert((... && Impl::check_size_t<T>()),
    │ │ │ │ +
    164 "HybridTreePath index storage must be std::size_t or std::integral_constant<std::size_t,v>");
    │ │ │ │ +
    165#endif
    │ │ │ │ +
    166
    │ │ │ │ +
    167 public:
    │ │ │ │
    168
    │ │ │ │ -
    169 template<typename... TC>
    │ │ │ │ -
    │ │ │ │ -
    170 static typename result<TC...>::storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t, std::shared_ptr<TC>... children)
    │ │ │ │ -
    171 {
    │ │ │ │ -
    172 return std::make_shared<typename result<TC...>::type>(s,t,children...);
    │ │ │ │ -
    173 }
    │ │ │ │ -
    │ │ │ │ -
    174
    │ │ │ │ -
    175 };
    │ │ │ │ -
    │ │ │ │ -
    176
    │ │ │ │ -
    177
    │ │ │ │ -
    178 template<typename SourceNode, typename Transformation, template<typename,typename...> class TransformedNode>
    │ │ │ │ -
    │ │ │ │ -
    179 struct GenericCompositeNodeTransformation
    │ │ │ │ -
    180 : public TemplatizedGenericCompositeNodeTransformation<SourceNode,
    │ │ │ │ -
    181 Transformation,
    │ │ │ │ -
    182 GenericCompositeNodeTransformationTemplate<SourceNode,
    │ │ │ │ -
    183 Transformation,
    │ │ │ │ -
    184 TransformedNode>::template result
    │ │ │ │ -
    185 >
    │ │ │ │ -
    186 {};
    │ │ │ │ -
    │ │ │ │ -
    187
    │ │ │ │ -
    189
    │ │ │ │ -
    190 } // namespace TypeTree
    │ │ │ │ -
    191} //namespace Dune
    │ │ │ │ +
    170 using index_sequence = std::index_sequence_for<T...>;
    │ │ │ │ +
    171
    │ │ │ │ +
    │ │ │ │ +
    173 constexpr HybridTreePath()
    │ │ │ │ +
    174 {
    │ │ │ │ +
    175 [[maybe_unused]] constexpr bool check =
    │ │ │ │ +
    176 (... && Impl::check_storage_type(MetaType<T>()) );
    │ │ │ │ +
    177 }
    │ │ │ │ +
    │ │ │ │ +
    178
    │ │ │ │ +
    179 constexpr HybridTreePath(const HybridTreePath& tp) = default;
    │ │ │ │ +
    180 constexpr HybridTreePath(HybridTreePath&& tp) = default;
    │ │ │ │ +
    181
    │ │ │ │ +
    182 constexpr HybridTreePath& operator=(const HybridTreePath& tp) = default;
    │ │ │ │ +
    183 constexpr HybridTreePath& operator=(HybridTreePath&& tp) = default;
    │ │ │ │ +
    184
    │ │ │ │ +
    │ │ │ │ +
    186 explicit constexpr HybridTreePath(std::tuple<T...> t)
    │ │ │ │ +
    187 : _data(t)
    │ │ │ │ +
    188 {
    │ │ │ │ +
    189 [[maybe_unused]] constexpr bool check =
    │ │ │ │ +
    190 (... && Impl::check_storage_type(MetaType<T>()) );
    │ │ │ │ +
    191 }
    │ │ │ │ +
    │ │ │ │
    192
    │ │ │ │ -
    193#endif // DUNE_TYPETREE_GENERICTRANSFORMATIONDESCRIPTORS_HH
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::StaticDegree
    decltype(Node::degree()) StaticDegree
    Returns the statically known degree of the given Node type as a std::integral_constant.
    Definition nodeinterface.hh:107
    │ │ │ │ +
    194 template<typename... U,
    │ │ │ │ +
    195 typename std::enable_if_t<(sizeof...(T) > 0 && sizeof...(U) == sizeof...(T)),bool> = true>
    │ │ │ │ +
    │ │ │ │ +
    196 explicit constexpr HybridTreePath(U... t)
    │ │ │ │ +
    197 : _data(t...) // we assume that all arguments are convertible to the types T...
    │ │ │ │ +
    198 {
    │ │ │ │ +
    199 [[maybe_unused]] constexpr bool check =
    │ │ │ │ +
    200 (... && Impl::check_storage_type(MetaType<T>()) );
    │ │ │ │ +
    201 }
    │ │ │ │ +
    │ │ │ │ +
    202
    │ │ │ │ +
    │ │ │ │ +
    204 [[nodiscard]] constexpr static index_sequence enumerate()
    │ │ │ │ +
    205 {
    │ │ │ │ +
    206 return {};
    │ │ │ │ +
    207 }
    │ │ │ │ +
    │ │ │ │ +
    208
    │ │ │ │ +
    │ │ │ │ +
    210 [[nodiscard]] constexpr static std::size_t size()
    │ │ │ │ +
    211 {
    │ │ │ │ +
    212 return sizeof...(T);
    │ │ │ │ +
    213 }
    │ │ │ │ +
    │ │ │ │ +
    214
    │ │ │ │ +
    │ │ │ │ +
    216 [[nodiscard]] constexpr static std::size_t max_size()
    │ │ │ │ +
    217 {
    │ │ │ │ +
    218 return size();
    │ │ │ │ +
    219 }
    │ │ │ │ +
    │ │ │ │ +
    220
    │ │ │ │ +
    222 template<std::size_t i,
    │ │ │ │ +
    223 std::enable_if_t<(sizeof...(T) > i),bool> = true>
    │ │ │ │ +
    │ │ │ │ +
    224 [[nodiscard]] constexpr auto operator[](Dune::index_constant<i>) const
    │ │ │ │ +
    225 {
    │ │ │ │ +
    226 return std::get<i>(_data);
    │ │ │ │ +
    227 }
    │ │ │ │ +
    │ │ │ │ +
    228
    │ │ │ │ +
    │ │ │ │ +
    230 [[nodiscard]] constexpr std::size_t operator[](std::size_t pos) const
    │ │ │ │ +
    231 {
    │ │ │ │ +
    232 std::size_t entry = 0;
    │ │ │ │ +
    233 Dune::Hybrid::forEach(enumerate(), [&] (auto i) {
    │ │ │ │ +
    234 if (i==pos)
    │ │ │ │ +
    235 entry = this->element(i);
    │ │ │ │ +
    236 });
    │ │ │ │ +
    237 return entry;
    │ │ │ │ +
    238 }
    │ │ │ │ +
    │ │ │ │ +
    239
    │ │ │ │ +
    241 template<std::size_t i,
    │ │ │ │ +
    242 std::enable_if_t<(sizeof...(T) > i),bool> = true>
    │ │ │ │ +
    │ │ │ │ +
    243 [[nodiscard]] constexpr auto element(Dune::index_constant<i> pos = {}) const
    │ │ │ │ +
    244 {
    │ │ │ │ +
    245 return std::get<i>(_data);
    │ │ │ │ +
    246 }
    │ │ │ │ +
    │ │ │ │ +
    247
    │ │ │ │ +
    │ │ │ │ +
    249 [[nodiscard]] constexpr std::size_t element(std::size_t pos) const
    │ │ │ │ +
    250 {
    │ │ │ │ +
    251 std::size_t entry = 0;
    │ │ │ │ +
    252 Dune::Hybrid::forEach(enumerate(), [&] (auto i) {
    │ │ │ │ +
    253 if (i==pos)
    │ │ │ │ +
    254 entry = this->element(i);
    │ │ │ │ +
    255 });
    │ │ │ │ +
    256 return entry;
    │ │ │ │ +
    257 }
    │ │ │ │ +
    │ │ │ │ +
    258
    │ │ │ │ +
    260 template<std::size_t n = sizeof...(T),
    │ │ │ │ +
    261 std::enable_if_t<(n > 0 && n == sizeof...(T)),bool> = true>
    │ │ │ │ +
    │ │ │ │ +
    262 [[nodiscard]] constexpr auto front() const
    │ │ │ │ +
    263 {
    │ │ │ │ +
    264 return std::get<0>(_data);
    │ │ │ │ +
    265 }
    │ │ │ │ +
    │ │ │ │ +
    266
    │ │ │ │ +
    268 template<std::size_t n = sizeof...(T),
    │ │ │ │ +
    269 std::enable_if_t<(n > 0 && n == sizeof...(T)),bool> = true>
    │ │ │ │ +
    │ │ │ │ +
    270 [[nodiscard]] constexpr auto back() const
    │ │ │ │ +
    271 {
    │ │ │ │ +
    272 return std::get<n-1>(_data);
    │ │ │ │ +
    273 }
    │ │ │ │ +
    │ │ │ │ +
    274
    │ │ │ │ +
    275#ifndef DOXYGEN
    │ │ │ │ +
    276
    │ │ │ │ +
    277 // I can't be bothered to make all the external accessors friends of HybridTreePath,
    │ │ │ │ +
    278 // so we'll only hide the data tuple from the user in Doxygen.
    │ │ │ │ +
    279
    │ │ │ │ +
    280 using Data = std::tuple<T...>;
    │ │ │ │ +
    281 Data _data;
    │ │ │ │ +
    282
    │ │ │ │ +
    283#endif // DOXYGEN
    │ │ │ │ +
    284
    │ │ │ │ +
    285 };
    │ │ │ │ +
    │ │ │ │ +
    286
    │ │ │ │ +
    288
    │ │ │ │ +
    294 template<typename... T>
    │ │ │ │ +
    │ │ │ │ +
    295 [[nodiscard]] constexpr auto makeTreePath(const T... t)
    │ │ │ │ +
    296 {
    │ │ │ │ +
    297 // check that all entries are based on std::size_t
    │ │ │ │ +
    298 static_assert((... && Impl::check_size_t<T>()),
    │ │ │ │ +
    299 "HybridTreePath indices must be of type std::size_t or std::integral_constant<std::size_t,v>");
    │ │ │ │ +
    300 return HybridTreePath<T...>(t...);
    │ │ │ │ +
    301 }
    │ │ │ │ +
    │ │ │ │ +
    302
    │ │ │ │ +
    304
    │ │ │ │ +
    311 template<typename... T>
    │ │ │ │ +
    │ │ │ │ +
    312 [[nodiscard]] constexpr auto hybridTreePath(const T&... t)
    │ │ │ │ +
    313 {
    │ │ │ │ +
    314 return makeTreePath(Impl::cast_size_t(t)...);
    │ │ │ │ +
    315 }
    │ │ │ │ +
    │ │ │ │ +
    316
    │ │ │ │ +
    318
    │ │ │ │ +
    325 template<typename... T>
    │ │ │ │ +
    │ │ │ │ +
    326 [[nodiscard]] constexpr auto treePath(const T&... t)
    │ │ │ │ +
    327 {
    │ │ │ │ +
    328 return makeTreePath(Impl::cast_size_t(t)...);
    │ │ │ │ +
    329 }
    │ │ │ │ +
    │ │ │ │ +
    330
    │ │ │ │ +
    331
    │ │ │ │ +
    333 template<typename... T>
    │ │ │ │ +
    │ │ │ │ +
    334 [[nodiscard]] constexpr std::size_t treePathSize(const HybridTreePath<T...>&)
    │ │ │ │ +
    335 {
    │ │ │ │ +
    336 return sizeof...(T);
    │ │ │ │ +
    337 }
    │ │ │ │ +
    │ │ │ │ +
    338
    │ │ │ │ +
    340
    │ │ │ │ +
    356 template<std::size_t i, typename... T>
    │ │ │ │ +
    │ │ │ │ +
    357 [[nodiscard]] constexpr auto treePathEntry(const HybridTreePath<T...>& tp, index_constant<i> = {})
    │ │ │ │ +
    358 -> typename std::decay<decltype(std::get<i>(tp._data))>::type
    │ │ │ │ +
    359 {
    │ │ │ │ +
    360 return std::get<i>(tp._data);
    │ │ │ │ +
    361 }
    │ │ │ │ +
    │ │ │ │ +
    362
    │ │ │ │ +
    364
    │ │ │ │ +
    379 template<std::size_t i,typename... T>
    │ │ │ │ +
    │ │ │ │ +
    380 [[nodiscard]] constexpr std::size_t treePathIndex(const HybridTreePath<T...>& tp, index_constant<i> = {})
    │ │ │ │ +
    381 {
    │ │ │ │ +
    382 return std::get<i>(tp._data);
    │ │ │ │ +
    383 }
    │ │ │ │ +
    │ │ │ │ +
    384
    │ │ │ │ +
    386
    │ │ │ │ +
    391 template<typename... T>
    │ │ │ │ +
    │ │ │ │ +
    392 [[nodiscard]] constexpr auto back(const HybridTreePath<T...>& tp)
    │ │ │ │ +
    393 -> decltype(tp.back())
    │ │ │ │ +
    394 {
    │ │ │ │ +
    395 return tp.back();
    │ │ │ │ +
    396 }
    │ │ │ │ +
    │ │ │ │ +
    397
    │ │ │ │ +
    399
    │ │ │ │ +
    404 template<typename... T>
    │ │ │ │ +
    │ │ │ │ +
    405 [[nodiscard]] constexpr auto front(const HybridTreePath<T...>& tp)
    │ │ │ │ +
    406 -> decltype(tp.front())
    │ │ │ │ +
    407 {
    │ │ │ │ +
    408 return tp.front();
    │ │ │ │ +
    409 }
    │ │ │ │ +
    │ │ │ │ +
    410
    │ │ │ │ +
    412
    │ │ │ │ +
    415 template<typename... T>
    │ │ │ │ +
    │ │ │ │ +
    416 [[nodiscard]] constexpr HybridTreePath<T...,std::size_t> push_back(const HybridTreePath<T...>& tp, std::size_t i)
    │ │ │ │ +
    417 {
    │ │ │ │ +
    418 return HybridTreePath<T...,std::size_t>(std::tuple_cat(tp._data,std::make_tuple(i)));
    │ │ │ │ +
    419 }
    │ │ │ │ +
    │ │ │ │ +
    420
    │ │ │ │ +
    422
    │ │ │ │ +
    436 template<std::size_t i, typename... T>
    │ │ │ │ +
    │ │ │ │ +
    437 [[nodiscard]] constexpr HybridTreePath<T...,index_constant<i>> push_back(const HybridTreePath<T...>& tp, index_constant<i> i_ = {})
    │ │ │ │ +
    438 {
    │ │ │ │ +
    439 return HybridTreePath<T...,index_constant<i> >(std::tuple_cat(tp._data,std::make_tuple(i_)));
    │ │ │ │ +
    440 }
    │ │ │ │ +
    │ │ │ │ +
    441
    │ │ │ │ +
    443
    │ │ │ │ +
    446 template<typename... T>
    │ │ │ │ +
    │ │ │ │ +
    447 [[nodiscard]] constexpr HybridTreePath<std::size_t,T...> push_front(const HybridTreePath<T...>& tp, std::size_t element)
    │ │ │ │ +
    448 {
    │ │ │ │ +
    449 return HybridTreePath<std::size_t,T...>(std::tuple_cat(std::make_tuple(element),tp._data));
    │ │ │ │ +
    450 }
    │ │ │ │ +
    │ │ │ │ +
    451
    │ │ │ │ +
    453
    │ │ │ │ +
    467 template<std::size_t i, typename... T>
    │ │ │ │ +
    │ │ │ │ +
    468 [[nodiscard]] constexpr HybridTreePath<index_constant<i>,T...> push_front(const HybridTreePath<T...>& tp, index_constant<i> _i = {})
    │ │ │ │ +
    469 {
    │ │ │ │ +
    470 return HybridTreePath<index_constant<i>,T...>(std::tuple_cat(std::make_tuple(_i),tp._data));
    │ │ │ │ +
    471 }
    │ │ │ │ +
    │ │ │ │ +
    472
    │ │ │ │ +
    474
    │ │ │ │ +
    485 template<typename I, typename... T, std::enable_if_t<(sizeof...(T) > 0),bool> = true>
    │ │ │ │ +
    │ │ │ │ +
    486 [[nodiscard]] constexpr auto accumulate_back(const HybridTreePath<T...>& tp, I i) {
    │ │ │ │ +
    487 using ::Dune::Hybrid::plus;
    │ │ │ │ +
    488 return push_back(pop_back(tp), plus(back(tp), i));
    │ │ │ │ +
    489 }
    │ │ │ │ +
    │ │ │ │ +
    490
    │ │ │ │ +
    491
    │ │ │ │ +
    493
    │ │ │ │ +
    504 template<typename I, typename... T, std::enable_if_t<(sizeof...(T) > 0),bool> = true>
    │ │ │ │ +
    │ │ │ │ +
    505 [[nodiscard]] constexpr auto accumulate_front(const HybridTreePath<T...>& tp, I i) {
    │ │ │ │ +
    506 using ::Dune::Hybrid::plus;
    │ │ │ │ +
    507 return push_front(pop_front(tp), plus(front(tp), i));
    │ │ │ │ +
    508 }
    │ │ │ │ +
    │ │ │ │ +
    509
    │ │ │ │ +
    511 template<class... Head, class... Other>
    │ │ │ │ +
    │ │ │ │ +
    512 [[nodiscard]] constexpr auto join(const HybridTreePath<Head...>& head, const Other&... tail) {
    │ │ │ │ +
    513 return TypeTree::HybridTreePath{std::tuple_cat(head._data, tail._data...)};
    │ │ │ │ +
    514 }
    │ │ │ │ +
    │ │ │ │ +
    515
    │ │ │ │ +
    517 template<class... T>
    │ │ │ │ +
    │ │ │ │ +
    518 [[nodiscard]] constexpr auto reverse(const HybridTreePath<T...>& tp) {
    │ │ │ │ +
    519 constexpr std::size_t size = sizeof...(T);
    │ │ │ │ +
    520 return unpackIntegerSequence([&](auto... i){
    │ │ │ │ +
    521 return treePath(tp[index_constant<size-i-1>{}] ...);
    │ │ │ │ +
    522 }, std::make_index_sequence<size>{});
    │ │ │ │ +
    523 }
    │ │ │ │ +
    │ │ │ │ +
    524
    │ │ │ │ +
    526
    │ │ │ │ +
    529 template <class... T, std::enable_if_t<(sizeof...(T) > 0),bool> = true>
    │ │ │ │ +
    │ │ │ │ +
    530 [[nodiscard]] constexpr auto pop_front(const HybridTreePath<T...>& tp)
    │ │ │ │ +
    531 {
    │ │ │ │ +
    532 return unpackIntegerSequence([&](auto... i){
    │ │ │ │ +
    533 return HybridTreePath{std::make_tuple(std::get<i+1>(tp._data)...)};
    │ │ │ │ +
    534 }, std::make_index_sequence<(sizeof...(T) - 1)>{});
    │ │ │ │ +
    535 }
    │ │ │ │ +
    │ │ │ │ +
    536
    │ │ │ │ +
    538
    │ │ │ │ +
    541 template <class... T, std::enable_if_t<(sizeof...(T) > 0),bool> = true>
    │ │ │ │ +
    │ │ │ │ +
    542 [[nodiscard]] constexpr auto pop_back(const HybridTreePath<T...>& tp)
    │ │ │ │ +
    543 {
    │ │ │ │ +
    544 return unpackIntegerSequence([&](auto... i){
    │ │ │ │ +
    545 return HybridTreePath{std::make_tuple(std::get<i>(tp._data)...)};
    │ │ │ │ +
    546 }, std::make_index_sequence<(sizeof...(T) - 1)>{});
    │ │ │ │ +
    547 }
    │ │ │ │ +
    │ │ │ │ +
    548
    │ │ │ │ +
    550
    │ │ │ │ +
    558 template <class... S, class... T>
    │ │ │ │ +
    │ │ │ │ +
    559 [[nodiscard]] constexpr bool operator==(
    │ │ │ │ +
    560 const HybridTreePath<S...>& lhs,
    │ │ │ │ +
    561 const HybridTreePath<T...>& rhs)
    │ │ │ │ +
    562 {
    │ │ │ │ +
    563 if constexpr (sizeof...(S) == sizeof...(T)) {
    │ │ │ │ +
    564 if constexpr ((Dune::IsInteroperable<S,T>::value &&...)) {
    │ │ │ │ +
    565 return unpackIntegerSequence([&](auto... i){
    │ │ │ │ +
    566 return ((std::get<i>(lhs._data) == std::get<i>(rhs._data)) &&...);
    │ │ │ │ +
    567 }, std::make_index_sequence<(sizeof...(S))>{});
    │ │ │ │ +
    568 } else {
    │ │ │ │ +
    569 return false;
    │ │ │ │ +
    570 }
    │ │ │ │ +
    571 } else {
    │ │ │ │ +
    572 return false;
    │ │ │ │ +
    573 }
    │ │ │ │ +
    574 }
    │ │ │ │ +
    │ │ │ │ +
    575
    │ │ │ │ +
    577
    │ │ │ │ +
    582 template <class S, S... lhs, class T, T... rhs>
    │ │ │ │ +
    │ │ │ │ +
    583 [[nodiscard]] constexpr auto operator==(
    │ │ │ │ +
    584 const HybridTreePath<std::integral_constant<S,lhs>...>&,
    │ │ │ │ +
    585 const HybridTreePath<std::integral_constant<T,rhs>...>&)
    │ │ │ │ +
    586 {
    │ │ │ │ +
    587 return std::bool_constant<hybridTreePath(lhs...) == hybridTreePath(rhs...)>{};
    │ │ │ │ +
    588 }
    │ │ │ │ +
    │ │ │ │ +
    589
    │ │ │ │ +
    590
    │ │ │ │ +
    592 template <class... S, class... T>
    │ │ │ │ +
    │ │ │ │ +
    593 [[nodiscard]] constexpr auto operator!=(
    │ │ │ │ +
    594 const HybridTreePath<S...>& lhs,
    │ │ │ │ +
    595 const HybridTreePath<T...>& rhs)
    │ │ │ │ +
    596 {
    │ │ │ │ +
    597 return !(lhs == rhs);
    │ │ │ │ +
    598 }
    │ │ │ │ +
    │ │ │ │ +
    599
    │ │ │ │ +
    601 template <class S, S... lhs, class T, T... rhs>
    │ │ │ │ +
    │ │ │ │ +
    602 [[nodiscard]] constexpr auto operator!=(
    │ │ │ │ +
    603 const HybridTreePath<std::integral_constant<S,lhs>...>&,
    │ │ │ │ +
    604 const HybridTreePath<std::integral_constant<T,rhs>...>&)
    │ │ │ │ +
    605 {
    │ │ │ │ +
    606 return std::bool_constant<hybridTreePath(lhs...) != hybridTreePath(rhs...)>{};
    │ │ │ │ +
    607 }
    │ │ │ │ +
    │ │ │ │ +
    608
    │ │ │ │ +
    609
    │ │ │ │ +
    │ │ │ │ +
    610 inline namespace Literals {
    │ │ │ │ +
    611
    │ │ │ │ +
    613
    │ │ │ │ +
    617 template <char... digits>
    │ │ │ │ +
    │ │ │ │ +
    618 constexpr auto operator"" _tp()
    │ │ │ │ +
    619 {
    │ │ │ │ +
    620 using namespace Dune::Indices::Literals;
    │ │ │ │ +
    621 return hybridTreePath(operator""_ic<digits...>());
    │ │ │ │ +
    622 }
    │ │ │ │ +
    │ │ │ │ +
    623
    │ │ │ │ +
    624 } // end namespace Literals
    │ │ │ │ +
    │ │ │ │ +
    625
    │ │ │ │ +
    626
    │ │ │ │ +
    627 template<std::size_t... i>
    │ │ │ │ +
    │ │ │ │ +
    628 struct TreePathSize<HybridTreePath<index_constant<i>...> >
    │ │ │ │ +
    629 : public index_constant<sizeof...(i)>
    │ │ │ │ +
    630 {};
    │ │ │ │ +
    │ │ │ │ +
    631
    │ │ │ │ +
    632
    │ │ │ │ +
    633 template<std::size_t k, std::size_t... i>
    │ │ │ │ +
    │ │ │ │ +
    634 struct TreePathPushBack<HybridTreePath<index_constant<i>...>,k>
    │ │ │ │ +
    635 {
    │ │ │ │ +
    636 typedef HybridTreePath<index_constant<i>...,index_constant<k>> type;
    │ │ │ │ +
    637 };
    │ │ │ │ +
    │ │ │ │ +
    638
    │ │ │ │ +
    639 template<std::size_t k, std::size_t... i>
    │ │ │ │ +
    │ │ │ │ +
    640 struct TreePathPushFront<HybridTreePath<index_constant<i>...>,k>
    │ │ │ │ +
    641 {
    │ │ │ │ +
    642 typedef HybridTreePath<index_constant<k>,index_constant<i>...> type;
    │ │ │ │ +
    643 };
    │ │ │ │ +
    │ │ │ │ +
    644
    │ │ │ │ +
    645 template<std::size_t k>
    │ │ │ │ +
    │ │ │ │ +
    646 struct TreePathBack<HybridTreePath<index_constant<k>>>
    │ │ │ │ +
    647 : public index_constant<k>
    │ │ │ │ +
    648 {};
    │ │ │ │ +
    │ │ │ │ +
    649
    │ │ │ │ +
    650 template<std::size_t j, std::size_t k, std::size_t... l>
    │ │ │ │ +
    │ │ │ │ +
    651 struct TreePathBack<HybridTreePath<index_constant<j>,index_constant<k>,index_constant<l>...>>
    │ │ │ │ +
    652 : public TreePathBack<HybridTreePath<index_constant<k>,index_constant<l>...>>
    │ │ │ │ +
    653 {};
    │ │ │ │ +
    │ │ │ │ +
    654
    │ │ │ │ +
    655 template<std::size_t k, std::size_t... i>
    │ │ │ │ +
    │ │ │ │ +
    656 struct TreePathFront<HybridTreePath<index_constant<k>,index_constant<i>...>>
    │ │ │ │ +
    657 : public index_constant<k>
    │ │ │ │ +
    658 {};
    │ │ │ │ +
    │ │ │ │ +
    659
    │ │ │ │ +
    660 template<std::size_t k, std::size_t... i>
    │ │ │ │ +
    │ │ │ │ +
    661 struct TreePathPopBack<HybridTreePath<index_constant<k>>,i...>
    │ │ │ │ +
    662 {
    │ │ │ │ +
    663 typedef HybridTreePath<index_constant<i>...> type;
    │ │ │ │ +
    664 };
    │ │ │ │ +
    │ │ │ │ +
    665
    │ │ │ │ +
    666 template<std::size_t j,
    │ │ │ │ +
    667 std::size_t k,
    │ │ │ │ +
    668 std::size_t... l,
    │ │ │ │ +
    669 std::size_t... i>
    │ │ │ │ +
    │ │ │ │ +
    670 struct TreePathPopBack<HybridTreePath<index_constant<j>,index_constant<k>,index_constant<l>...>,i...>
    │ │ │ │ +
    671 : public TreePathPopBack<HybridTreePath<index_constant<k>,index_constant<l>...>,i...,j>
    │ │ │ │ +
    672 {};
    │ │ │ │ +
    │ │ │ │ +
    673
    │ │ │ │ +
    674 template<std::size_t k, std::size_t... i>
    │ │ │ │ +
    │ │ │ │ +
    675 struct TreePathPopFront<HybridTreePath<index_constant<k>,index_constant<i>...> >
    │ │ │ │ +
    676 {
    │ │ │ │ +
    677 typedef HybridTreePath<index_constant<i>...> type;
    │ │ │ │ +
    678 };
    │ │ │ │ +
    │ │ │ │ +
    679
    │ │ │ │ +
    680 template<std::size_t... i, std::size_t... k>
    │ │ │ │ +
    │ │ │ │ +
    681 struct TreePathConcat<HybridTreePath<index_constant<i>...>,HybridTreePath<index_constant<k>...> >
    │ │ │ │ +
    682 {
    │ │ │ │ +
    683 typedef HybridTreePath<index_constant<i>...,index_constant<k>...> type;
    │ │ │ │ +
    684 };
    │ │ │ │ +
    │ │ │ │ +
    685
    │ │ │ │ +
    686#ifndef DOXYGEN
    │ │ │ │ +
    687
    │ │ │ │ +
    688 namespace impl {
    │ │ │ │ +
    689
    │ │ │ │ +
    690 // end of recursion
    │ │ │ │ +
    691 template<std::size_t i, typename... T>
    │ │ │ │ +
    692 typename std::enable_if<
    │ │ │ │ +
    693 (i == sizeof...(T))
    │ │ │ │ +
    694 >::type
    │ │ │ │ +
    695 print_hybrid_tree_path(std::ostream& os, const HybridTreePath<T...>& tp, index_constant<i> _i)
    │ │ │ │ +
    696 {}
    │ │ │ │ +
    697
    │ │ │ │ +
    698 // print current entry and recurse
    │ │ │ │ +
    699 template<std::size_t i, typename... T>
    │ │ │ │ +
    700 typename std::enable_if<
    │ │ │ │ +
    701 (i < sizeof...(T))
    │ │ │ │ +
    702 >::type
    │ │ │ │ +
    703 print_hybrid_tree_path(std::ostream& os, const HybridTreePath<T...>& tp, index_constant<i> _i)
    │ │ │ │ +
    704 {
    │ │ │ │ +
    705 os << treePathIndex(tp,_i) << " ";
    │ │ │ │ +
    706 print_hybrid_tree_path(os,tp,index_constant<i+1>{});
    │ │ │ │ +
    707 }
    │ │ │ │ +
    708
    │ │ │ │ +
    709 } // namespace impl
    │ │ │ │ +
    710
    │ │ │ │ +
    711#endif // DOXYGEN
    │ │ │ │ +
    712
    │ │ │ │ +
    714 template<typename... T>
    │ │ │ │ +
    │ │ │ │ +
    715 std::ostream& operator<<(std::ostream& os, const HybridTreePath<T...>& tp)
    │ │ │ │ +
    716 {
    │ │ │ │ +
    717 os << "HybridTreePath< ";
    │ │ │ │ +
    718 impl::print_hybrid_tree_path(os, tp, index_constant<0>{});
    │ │ │ │ +
    719 os << ">";
    │ │ │ │ +
    720 return os;
    │ │ │ │ +
    721 }
    │ │ │ │ +
    │ │ │ │ +
    722
    │ │ │ │ +
    723 template<std::size_t... i>
    │ │ │ │ +
    724 using StaticTreePath = HybridTreePath<Dune::index_constant<i>...>;
    │ │ │ │ +
    725
    │ │ │ │ +
    727
    │ │ │ │ +
    728 } // namespace TypeTree
    │ │ │ │ +
    729} //namespace Dune
    │ │ │ │ +
    730
    │ │ │ │ +
    731#endif // DUNE_TYPETREE_TREEPATH_HH
    │ │ │ │ + │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::push_back
    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
    │ │ │ │ +
    Dune::TypeTree::operator<<
    std::ostream & operator<<(std::ostream &os, const HybridTreePath< T... > &tp)
    Dumps a HybridTreePath to a stream.
    Definition treepath.hh:715
    │ │ │ │ +
    Dune::TypeTree::treePathSize
    constexpr std::size_t treePathSize(const HybridTreePath< T... > &)
    Returns the size (number of components) of the given HybridTreePath.
    Definition treepath.hh:334
    │ │ │ │ +
    Dune::TypeTree::back
    constexpr auto back(const HybridTreePath< T... > &tp) -> decltype(tp.back())
    Returns a copy of the last element of the HybridTreePath.
    Definition treepath.hh:392
    │ │ │ │ +
    Dune::TypeTree::push_front
    constexpr HybridTreePath< std::size_t, T... > push_front(const HybridTreePath< T... > &tp, std::size_t element)
    Prepends a run time index to a HybridTreePath.
    Definition treepath.hh:447
    │ │ │ │ +
    Dune::TypeTree::accumulate_front
    constexpr auto accumulate_front(const HybridTreePath< T... > &tp, I i)
    Hybrid utility that accumulates to the front of a multi-index.
    Definition treepath.hh:505
    │ │ │ │ +
    Dune::TypeTree::pop_front
    constexpr auto pop_front(const HybridTreePath< T... > &tp)
    Removes first index on a HybridTreePath.
    Definition treepath.hh:530
    │ │ │ │ +
    Dune::TypeTree::reverse
    constexpr auto reverse(const HybridTreePath< T... > &tp)
    Reverses the order of the elements in the path.
    Definition treepath.hh:518
    │ │ │ │ +
    Dune::TypeTree::accumulate_back
    constexpr auto accumulate_back(const HybridTreePath< T... > &tp, I i)
    Hybrid utility that accumulates to the back of a multi-index.
    Definition treepath.hh:486
    │ │ │ │ +
    Dune::TypeTree::join
    constexpr auto join(const HybridTreePath< Head... > &head, const Other &... tail)
    Join two tree paths into one.
    Definition treepath.hh:512
    │ │ │ │ +
    Dune::TypeTree::treePathEntry
    constexpr auto treePathEntry(const HybridTreePath< T... > &tp, index_constant< i >={}) -> typename std::decay< decltype(std::get< i >(tp._data))>::type
    Returns a copy of the i-th element of the HybridTreePath.
    Definition treepath.hh:357
    │ │ │ │ +
    Dune::TypeTree::pop_back
    constexpr auto pop_back(const HybridTreePath< T... > &tp)
    Removes last index on a HybridTreePath.
    Definition treepath.hh:542
    │ │ │ │ +
    Dune::TypeTree::operator!=
    constexpr auto operator!=(const HybridTreePath< S... > &lhs, const HybridTreePath< T... > &rhs)
    Compare two HybridTreePaths for unequality.
    Definition treepath.hh:593
    │ │ │ │ +
    Dune::TypeTree::hybridTreePath
    constexpr auto hybridTreePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:312
    │ │ │ │ +
    Dune::TypeTree::treePathIndex
    constexpr std::size_t treePathIndex(const HybridTreePath< T... > &tp, index_constant< i >={})
    Returns the index value of the i-th element of the HybridTreePath.
    Definition treepath.hh:380
    │ │ │ │ +
    Dune::TypeTree::makeTreePath
    constexpr auto makeTreePath(const T... t)
    helper function to construct a new HybridTreePath from the given indices.
    Definition treepath.hh:295
    │ │ │ │ +
    Dune::TypeTree::operator==
    constexpr bool operator==(const HybridTreePath< S... > &lhs, const HybridTreePath< T... > &rhs)
    Compare two HybridTreePaths for value equality.
    Definition treepath.hh:559
    │ │ │ │ +
    Dune::TypeTree::print_tree_path
    void print_tree_path(std::ostream &os)
    Definition treepath.hh:134
    │ │ │ │ +
    Dune::TypeTree::treePath
    constexpr auto treePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:326
    │ │ │ │ +
    Dune::TypeTree::front
    constexpr auto front(const HybridTreePath< T... > &tp) -> decltype(tp.front())
    Returns a copy of the first element of the HybridTreePath.
    Definition treepath.hh:405
    │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::GenericLeafNodeTransformation
    Definition generictransformationdescriptors.hh:28
    │ │ │ │ -
    Dune::TypeTree::GenericLeafNodeTransformation::transformed_type
    TransformedNode transformed_type
    Definition generictransformationdescriptors.hh:32
    │ │ │ │ -
    Dune::TypeTree::GenericLeafNodeTransformation::transformed_storage_type
    std::shared_ptr< transformed_type > transformed_storage_type
    Definition generictransformationdescriptors.hh:33
    │ │ │ │ -
    Dune::TypeTree::GenericLeafNodeTransformation::transform
    static transformed_type transform(std::shared_ptr< const SourceNode > s, const Transformation &t)
    Definition generictransformationdescriptors.hh:40
    │ │ │ │ -
    Dune::TypeTree::GenericLeafNodeTransformation::recursive
    static const bool recursive
    Definition generictransformationdescriptors.hh:30
    │ │ │ │ -
    Dune::TypeTree::GenericLeafNodeTransformation::transform_storage
    static transformed_storage_type transform_storage(std::shared_ptr< const SourceNode > s, const Transformation &t)
    Definition generictransformationdescriptors.hh:45
    │ │ │ │ -
    Dune::TypeTree::GenericLeafNodeTransformation::transform
    static transformed_type transform(const SourceNode &s, const Transformation &t)
    Definition generictransformationdescriptors.hh:35
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation
    Definition generictransformationdescriptors.hh:55
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation::transform_storage
    static result< TC >::storage_type transform_storage(std::shared_ptr< const SourceNode > s, const Transformation &t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children)
    Definition generictransformationdescriptors.hh:80
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation::recursive
    static const bool recursive
    Definition generictransformationdescriptors.hh:57
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation::transform
    static result< TC >::type transform(std::shared_ptr< const SourceNode > s, const Transformation &t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children)
    Definition generictransformationdescriptors.hh:74
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation::transform
    static result< TC >::type transform(const SourceNode &s, const Transformation &t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children)
    Definition generictransformationdescriptors.hh:68
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation::result
    Definition generictransformationdescriptors.hh:61
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation::result::type
    TransformedNodeTemplate< TC >::type type
    Definition generictransformationdescriptors.hh:62
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation::result::degree
    static const std::size_t degree
    Definition generictransformationdescriptors.hh:64
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation::result::storage_type
    std::shared_ptr< type > storage_type
    Definition generictransformationdescriptors.hh:63
    │ │ │ │ -
    Dune::TypeTree::GenericPowerNodeTransformation
    Definition generictransformationdescriptors.hh:96
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation
    Definition generictransformationdescriptors.hh:101
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation::transform
    static result< TC >::type transform(std::shared_ptr< const SourceNode > s, const Transformation &t, const std::vector< std::shared_ptr< TC > > &children)
    Definition generictransformationdescriptors.hh:119
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation::recursive
    static const bool recursive
    Definition generictransformationdescriptors.hh:103
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation::transform
    static result< TC >::type transform(const SourceNode &s, const Transformation &t, const std::vector< std::shared_ptr< TC > > &children)
    Definition generictransformationdescriptors.hh:113
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation::transform_storage
    static result< TC >::storage_type transform_storage(std::shared_ptr< const SourceNode > s, const Transformation &t, const std::vector< std::shared_ptr< TC > > &children)
    Definition generictransformationdescriptors.hh:125
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation::result
    Definition generictransformationdescriptors.hh:107
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation::result::type
    TransformedNodeTemplate< TC >::type type
    Definition generictransformationdescriptors.hh:108
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation::result::storage_type
    std::shared_ptr< type > storage_type
    Definition generictransformationdescriptors.hh:109
    │ │ │ │ -
    Dune::TypeTree::GenericDynamicPowerNodeTransformation
    Definition generictransformationdescriptors.hh:141
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation
    Definition generictransformationdescriptors.hh:146
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation::transform
    static result< TC... >::type transform(const SourceNode &s, const Transformation &t, std::shared_ptr< TC >... children)
    Definition generictransformationdescriptors.hh:158
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation::transform_storage
    static result< TC... >::storage_type transform_storage(std::shared_ptr< const SourceNode > s, const Transformation &t, std::shared_ptr< TC >... children)
    Definition generictransformationdescriptors.hh:170
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation::transform
    static result< TC... >::type transform(std::shared_ptr< const SourceNode > s, const Transformation &t, std::shared_ptr< TC >... children)
    Definition generictransformationdescriptors.hh:164
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation::recursive
    static const bool recursive
    Definition generictransformationdescriptors.hh:148
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation::result
    Definition generictransformationdescriptors.hh:152
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation::result::type
    TransformedNodeTemplate< TC... >::type type
    Definition generictransformationdescriptors.hh:153
    │ │ │ │ -
    Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation::result::storage_type
    std::shared_ptr< type > storage_type
    Definition generictransformationdescriptors.hh:154
    │ │ │ │ -
    Dune::TypeTree::GenericCompositeNodeTransformation
    Definition generictransformationdescriptors.hh:186
    │ │ │ │ +
    Dune::TypeTree::TreePathType::Type
    Type
    Definition treepath.hh:106
    │ │ │ │ +
    Dune::TypeTree::TreePathType::fullyStatic
    @ fullyStatic
    Definition treepath.hh:106
    │ │ │ │ +
    Dune::TypeTree::TreePathType::dynamic
    @ dynamic
    Definition treepath.hh:106
    │ │ │ │ +
    Dune::TypeTree::plus
    Statically combine two values of type result_type using +.
    Definition accumulate_static.hh:49
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath
    A hybrid version of TreePath that supports both compile time and run time indices.
    Definition treepath.hh:158
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath::HybridTreePath
    constexpr HybridTreePath(HybridTreePath &&tp)=default
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath::back
    constexpr auto back() const
    Get the last index value. Only available in non-empty paths.
    Definition treepath.hh:270
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath::operator=
    constexpr HybridTreePath & operator=(const HybridTreePath &tp)=default
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath::element
    constexpr std::size_t element(std::size_t pos) const
    Get the index value at position pos.
    Definition treepath.hh:249
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath::HybridTreePath
    constexpr HybridTreePath(std::tuple< T... > t)
    Constructor from a std::tuple
    Definition treepath.hh:186
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath::operator=
    constexpr HybridTreePath & operator=(HybridTreePath &&tp)=default
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath::HybridTreePath
    constexpr HybridTreePath(U... t)
    Constructor from arguments.
    Definition treepath.hh:196
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath::HybridTreePath
    constexpr HybridTreePath()
    Default constructor.
    Definition treepath.hh:173
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath::element
    constexpr auto element(Dune::index_constant< i > pos={}) const
    Get the last index value.
    Definition treepath.hh:243
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath::size
    static constexpr std::size_t size()
    Get the size (length) of this path.
    Definition treepath.hh:210
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath::operator[]
    constexpr auto operator[](Dune::index_constant< i >) const
    Get the index value at position pos.
    Definition treepath.hh:224
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath::front
    constexpr auto front() const
    Get the first index value. Only available in non-empty paths.
    Definition treepath.hh:262
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath::enumerate
    static constexpr index_sequence enumerate()
    Returns an index_sequence for enumerating the components of this HybridTreePath.
    Definition treepath.hh:204
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath::HybridTreePath
    constexpr HybridTreePath(const HybridTreePath &tp)=default
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath::operator[]
    constexpr std::size_t operator[](std::size_t pos) const
    Get the index value at position pos.
    Definition treepath.hh:230
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath::max_size
    static constexpr std::size_t max_size()
    Get the size (length) of this path.
    Definition treepath.hh:216
    │ │ │ │ +
    Dune::TypeTree::HybridTreePath::index_sequence
    std::index_sequence_for< T... > index_sequence
    An index_sequence for the entries in this HybridTreePath.
    Definition treepath.hh:170
    │ │ │ │ +
    Dune::TypeTree::TreePathSize
    Definition treepath.hh:110
    │ │ │ │ +
    Dune::TypeTree::TreePathPushBack
    Definition treepath.hh:113
    │ │ │ │ +
    Dune::TypeTree::TreePathPushFront
    Definition treepath.hh:116
    │ │ │ │ +
    Dune::TypeTree::TreePathBack
    Definition treepath.hh:119
    │ │ │ │ +
    Dune::TypeTree::TreePathFront
    Definition treepath.hh:122
    │ │ │ │ +
    Dune::TypeTree::TreePathPopBack
    Definition treepath.hh:125
    │ │ │ │ +
    Dune::TypeTree::TreePathPopFront
    Definition treepath.hh:128
    │ │ │ │ +
    Dune::TypeTree::TreePathConcat
    Definition treepath.hh:131
    │ │ │ │ +
    Dune::TypeTree::TreePathPushBack< HybridTreePath< index_constant< i >... >, k >::type
    HybridTreePath< index_constant< i >..., index_constant< k > > type
    Definition treepath.hh:636
    │ │ │ │ +
    Dune::TypeTree::TreePathPushFront< HybridTreePath< index_constant< i >... >, k >::type
    HybridTreePath< index_constant< k >, index_constant< i >... > type
    Definition treepath.hh:642
    │ │ │ │ +
    Dune::TypeTree::TreePathPopBack< HybridTreePath< index_constant< k > >, i... >::type
    HybridTreePath< index_constant< i >... > type
    Definition treepath.hh:663
    │ │ │ │ +
    Dune::TypeTree::TreePathPopFront< HybridTreePath< index_constant< k >, index_constant< i >... > >::type
    HybridTreePath< index_constant< i >... > type
    Definition treepath.hh:677
    │ │ │ │ +
    Dune::TypeTree::TreePathConcat< HybridTreePath< index_constant< i >... >, HybridTreePath< index_constant< k >... > >::type
    HybridTreePath< index_constant< i >..., index_constant< k >... > type
    Definition treepath.hh:683
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,347 +1,812 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -generictransformationdescriptors.hh │ │ │ │ │ +treepath.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: │ │ │ │ │ +1// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- │ │ │ │ │ +2// vi: set et ts=8 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_GENERICTRANSFORMATIONDESCRIPTORS_HH │ │ │ │ │ -7#define DUNE_TYPETREE_GENERICTRANSFORMATIONDESCRIPTORS_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_TREEPATH_HH │ │ │ │ │ +7#define DUNE_TYPETREE_TREEPATH_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include │ │ │ │ │ -10#include │ │ │ │ │ -11 │ │ │ │ │ -12#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> │ │ │ │ │ -13#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ -14#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_p_o_w_e_r_c_o_m_p_o_s_i_t_e_n_o_d_e_t_r_a_n_s_f_o_r_m_a_t_i_o_n_t_e_m_p_l_a_t_e_s_._h_h> │ │ │ │ │ -15#include │ │ │ │ │ -16 │ │ │ │ │ -17 │ │ │ │ │ -18namespace _D_u_n_e { │ │ │ │ │ -19 namespace TypeTree { │ │ │ │ │ +9#include │ │ │ │ │ +10#include │ │ │ │ │ +11#include │ │ │ │ │ +12#include │ │ │ │ │ +13 │ │ │ │ │ +14#include │ │ │ │ │ +15#include │ │ │ │ │ +16#include │ │ │ │ │ +17#include │ │ │ │ │ +18#include │ │ │ │ │ +19#include │ │ │ │ │ 20 │ │ │ │ │ -26 template │ │ │ │ │ -_2_7 struct _G_e_n_e_r_i_c_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -28 { │ │ │ │ │ -29 │ │ │ │ │ -_3_0 static const bool _r_e_c_u_r_s_i_v_e = false; │ │ │ │ │ -31 │ │ │ │ │ -_3_2 typedef TransformedNode _t_r_a_n_s_f_o_r_m_e_d___t_y_p_e; │ │ │ │ │ -_3_3 typedef std::shared_ptr _t_r_a_n_s_f_o_r_m_e_d___s_t_o_r_a_g_e___t_y_p_e; │ │ │ │ │ -34 │ │ │ │ │ -_3_5 static _t_r_a_n_s_f_o_r_m_e_d___t_y_p_e _t_r_a_n_s_f_o_r_m(const SourceNode& s, const Transformation& │ │ │ │ │ -t) │ │ │ │ │ -36 { │ │ │ │ │ -37 return _t_r_a_n_s_f_o_r_m_e_d___t_y_p_e(s,t); │ │ │ │ │ -38 } │ │ │ │ │ -39 │ │ │ │ │ -_4_0 static _t_r_a_n_s_f_o_r_m_e_d___t_y_p_e _t_r_a_n_s_f_o_r_m(std::shared_ptr s, const │ │ │ │ │ -Transformation& t) │ │ │ │ │ -41 { │ │ │ │ │ -42 return _t_r_a_n_s_f_o_r_m_e_d___t_y_p_e(s,t); │ │ │ │ │ -43 } │ │ │ │ │ +21#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_f_i_x_e_d_c_a_p_a_c_i_t_y_s_t_a_c_k_._h_h> │ │ │ │ │ +22#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_u_t_i_l_i_t_y_._h_h> │ │ │ │ │ +23 │ │ │ │ │ +24namespace _D_u_n_e { │ │ │ │ │ +25 namespace TypeTree { │ │ │ │ │ +26 │ │ │ │ │ +27 // The Impl namespace collects some free standing functions helper functions │ │ │ │ │ +28 namespace Impl { │ │ │ │ │ +29 template │ │ │ │ │ +30 struct check_size_t_impl │ │ │ │ │ +31 { │ │ │ │ │ +32 static constexpr auto check() { │ │ │ │ │ +33 return std::is_same_v; │ │ │ │ │ +34 } │ │ │ │ │ +35 }; │ │ │ │ │ +36 │ │ │ │ │ +37 template │ │ │ │ │ +38 struct check_size_t_impl> │ │ │ │ │ +39 { │ │ │ │ │ +40 static constexpr auto check() { │ │ │ │ │ +41 return std::is_same_v; │ │ │ │ │ +42 } │ │ │ │ │ +43 }; │ │ │ │ │ 44 │ │ │ │ │ -_4_5 static _t_r_a_n_s_f_o_r_m_e_d___s_t_o_r_a_g_e___t_y_p_e _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std::shared_ptr s, const Transformation& t) │ │ │ │ │ -46 { │ │ │ │ │ -47 return std::make_shared(s,t); │ │ │ │ │ +45 template │ │ │ │ │ +46 constexpr auto check_size_t() { │ │ │ │ │ +47 return check_size_t_impl::check(); │ │ │ │ │ 48 } │ │ │ │ │ 49 │ │ │ │ │ -50 }; │ │ │ │ │ -51 │ │ │ │ │ -52 │ │ │ │ │ -53 template class TransformedNodeTemplate> │ │ │ │ │ -_5_4 struct _T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -55 { │ │ │ │ │ -56 │ │ │ │ │ -_5_7 static const bool _r_e_c_u_r_s_i_v_e = true; │ │ │ │ │ -58 │ │ │ │ │ -59 template │ │ │ │ │ -_6_0 struct _r_e_s_u_l_t │ │ │ │ │ -61 { │ │ │ │ │ -_6_2 typedef typename TransformedNodeTemplate::type _t_y_p_e; │ │ │ │ │ -_6_3 typedef std::shared_ptr _s_t_o_r_a_g_e___t_y_p_e; │ │ │ │ │ -_6_4 static const std::size_t _d_e_g_r_e_e = _S_t_a_t_i_c_D_e_g_r_e_e_<_t_y_p_e_>_:_:_v_a_l_u_e; │ │ │ │ │ -65 }; │ │ │ │ │ -66 │ │ │ │ │ -67 template │ │ │ │ │ -_6_8 static typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e _t_r_a_n_s_f_o_r_m(const SourceNode& s, const │ │ │ │ │ -Transformation& t, const std::array,_r_e_s_u_l_t_<_T_C_>_:_:_d_e_g_r_e_e>& │ │ │ │ │ -children) │ │ │ │ │ -69 { │ │ │ │ │ -70 return typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e(s,t,children); │ │ │ │ │ -71 } │ │ │ │ │ -72 │ │ │ │ │ -73 template │ │ │ │ │ -_7_4 static typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e _t_r_a_n_s_f_o_r_m(std::shared_ptr │ │ │ │ │ -s, const Transformation& t, const std::array,_r_e_s_u_l_t_<_T_C_>_:_: │ │ │ │ │ -_d_e_g_r_e_e>& children) │ │ │ │ │ -75 { │ │ │ │ │ -76 return typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e(s,t,children); │ │ │ │ │ -77 } │ │ │ │ │ -78 │ │ │ │ │ -79 template │ │ │ │ │ -_8_0 static typename _r_e_s_u_l_t_<_T_C_>_:_:_s_t_o_r_a_g_e___t_y_p_e _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std:: │ │ │ │ │ -shared_ptr s, const Transformation& t, const std::array,_r_e_s_u_l_t_<_T_C_>_:_:_d_e_g_r_e_e>& children) │ │ │ │ │ -81 { │ │ │ │ │ -82 return std::make_shared::type>(s,t,children); │ │ │ │ │ -83 } │ │ │ │ │ -84 │ │ │ │ │ -85 }; │ │ │ │ │ -86 │ │ │ │ │ -87 │ │ │ │ │ -88 template class TransformedNode> │ │ │ │ │ -_8_9 struct _G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -90 : public _T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n::template result │ │ │ │ │ -95 > │ │ │ │ │ -96 {}; │ │ │ │ │ +50 template │ │ │ │ │ +51 constexpr auto cast_size_t(const T & v) { │ │ │ │ │ +52 // check that T is an integral type that can be cast to std::size_t │ │ │ │ │ +53 static_assert( │ │ │ │ │ +54 std::is_convertible_v && │ │ │ │ │ +55 std::is_integral_v, │ │ │ │ │ +56 "HybridTreePath indices must be convertible to std::size_t or std:: │ │ │ │ │ +integral_constant"); │ │ │ │ │ +57 // positivity can only be checked at run-time │ │ │ │ │ +58 assert(v >= 0 && │ │ │ │ │ +59 "HybridTreePath indices must be convertible to std::size_t or std:: │ │ │ │ │ +integral_constant"); │ │ │ │ │ +60 return std::size_t(v); │ │ │ │ │ +61 } │ │ │ │ │ +62 │ │ │ │ │ +63 template │ │ │ │ │ +64 constexpr auto cast_size_t(std::integral_constant) { │ │ │ │ │ +65 // check that T is an intergal type that can be cast to std::size_t │ │ │ │ │ +66 // and that v is positive │ │ │ │ │ +67 static_assert( │ │ │ │ │ +68 std::is_convertible_v && │ │ │ │ │ +69 std::is_integral_v && │ │ │ │ │ +70 v >= 0, │ │ │ │ │ +71 "HybridTreePath indices must be convertible to std::size_t or std:: │ │ │ │ │ +integral_constant"); │ │ │ │ │ +72 return std::integral_constant(); │ │ │ │ │ +73 } │ │ │ │ │ +74 │ │ │ │ │ +75 // these are helper functions that help triggering a deprecation warning │ │ │ │ │ +76 template │ │ │ │ │ +77 [[deprecated("HybridTreePath index storage should be std::size_t or std:: │ │ │ │ │ +integral_constant!\n" │ │ │ │ │ +78 "Using anything else is deprecated and will not possible after the 2.10 │ │ │ │ │ +release.\n" │ │ │ │ │ +79 "It is adviced not to specify the template parameters expicitly,\n" │ │ │ │ │ +80 "but to use the helper functions `hybridTreePath` or `treePath`." │ │ │ │ │ +81 "These take care of converting indices to the appropriate storage.")]] │ │ │ │ │ +82 constexpr bool check_storage_type(MetaType) { │ │ │ │ │ +83 return false; │ │ │ │ │ +84 } │ │ │ │ │ +85 │ │ │ │ │ +86 // specialization of valid index type │ │ │ │ │ +87 template │ │ │ │ │ +88 constexpr bool check_storage_type(MetaType>) { │ │ │ │ │ +89 return true; │ │ │ │ │ +90 } │ │ │ │ │ +91 │ │ │ │ │ +92 // specialization of valid index type │ │ │ │ │ +93 constexpr bool check_storage_type(MetaType) { │ │ │ │ │ +94 return true; │ │ │ │ │ +95 } │ │ │ │ │ +96 } │ │ │ │ │ 97 │ │ │ │ │ -98 │ │ │ │ │ -99 template class TransformedNodeTemplate> │ │ │ │ │ -_1_0_0 struct _T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -101 { │ │ │ │ │ -102 │ │ │ │ │ -_1_0_3 static const bool _r_e_c_u_r_s_i_v_e = true; │ │ │ │ │ +98 template │ │ │ │ │ +99 class HybridTreePath; │ │ │ │ │ +100 │ │ │ │ │ 104 │ │ │ │ │ -105 template │ │ │ │ │ -_1_0_6 struct _r_e_s_u_l_t │ │ │ │ │ -107 { │ │ │ │ │ -_1_0_8 typedef typename TransformedNodeTemplate::type _t_y_p_e; │ │ │ │ │ -_1_0_9 typedef std::shared_ptr _s_t_o_r_a_g_e___t_y_p_e; │ │ │ │ │ -110 }; │ │ │ │ │ +_1_0_5 namespace TreePathType { │ │ │ │ │ +_1_0_6 enum _T_y_p_e { _f_u_l_l_y_S_t_a_t_i_c, _d_y_n_a_m_i_c }; │ │ │ │ │ +107 } │ │ │ │ │ +108 │ │ │ │ │ +109 template │ │ │ │ │ +_1_1_0 struct _T_r_e_e_P_a_t_h_S_i_z_e; │ │ │ │ │ 111 │ │ │ │ │ -112 template │ │ │ │ │ -_1_1_3 static typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e _t_r_a_n_s_f_o_r_m(const SourceNode& s, const │ │ │ │ │ -Transformation& t, const std::vector>& children) │ │ │ │ │ -114 { │ │ │ │ │ -115 return typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e(s,t,children); │ │ │ │ │ -116 } │ │ │ │ │ +112 template │ │ │ │ │ +_1_1_3 struct _T_r_e_e_P_a_t_h_P_u_s_h_B_a_c_k; │ │ │ │ │ +114 │ │ │ │ │ +115 template │ │ │ │ │ +_1_1_6 struct _T_r_e_e_P_a_t_h_P_u_s_h_F_r_o_n_t; │ │ │ │ │ 117 │ │ │ │ │ -118 template │ │ │ │ │ -_1_1_9 static typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e _t_r_a_n_s_f_o_r_m(std::shared_ptr s, const Transformation& t, const std::vector>& │ │ │ │ │ -children) │ │ │ │ │ -120 { │ │ │ │ │ -121 return typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e(s,t,children); │ │ │ │ │ -122 } │ │ │ │ │ +118 template │ │ │ │ │ +_1_1_9 struct _T_r_e_e_P_a_t_h_B_a_c_k; │ │ │ │ │ +120 │ │ │ │ │ +121 template │ │ │ │ │ +_1_2_2 struct _T_r_e_e_P_a_t_h_F_r_o_n_t; │ │ │ │ │ 123 │ │ │ │ │ -124 template │ │ │ │ │ -_1_2_5 static typename _r_e_s_u_l_t_<_T_C_>_:_:_s_t_o_r_a_g_e___t_y_p_e _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std:: │ │ │ │ │ -shared_ptr s, const Transformation& t, const std:: │ │ │ │ │ -vector>& children) │ │ │ │ │ -126 { │ │ │ │ │ -127 return std::make_shared::type>(s,t,children); │ │ │ │ │ -128 } │ │ │ │ │ +124 template │ │ │ │ │ +_1_2_5 struct _T_r_e_e_P_a_t_h_P_o_p_B_a_c_k; │ │ │ │ │ +126 │ │ │ │ │ +127 template │ │ │ │ │ +_1_2_8 struct _T_r_e_e_P_a_t_h_P_o_p_F_r_o_n_t; │ │ │ │ │ 129 │ │ │ │ │ -130 }; │ │ │ │ │ -131 │ │ │ │ │ +130 template │ │ │ │ │ +_1_3_1 struct _T_r_e_e_P_a_t_h_C_o_n_c_a_t; │ │ │ │ │ 132 │ │ │ │ │ -133 template class TransformedNode> │ │ │ │ │ -_1_3_4 struct _G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -135 : public _T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n::template result │ │ │ │ │ -140 > │ │ │ │ │ -141 {}; │ │ │ │ │ -142 │ │ │ │ │ +133 template │ │ │ │ │ +_1_3_4 void _p_r_i_n_t___t_r_e_e___p_a_t_h(std::ostream& os) │ │ │ │ │ +135 {} │ │ │ │ │ +136 │ │ │ │ │ +137 template │ │ │ │ │ +_1_3_8 void _p_r_i_n_t___t_r_e_e___p_a_t_h(std::ostream& os) │ │ │ │ │ +139 { │ │ │ │ │ +140 os << k << " "; │ │ │ │ │ +141 _p_r_i_n_t___t_r_e_e___p_a_t_h(os); │ │ │ │ │ +142 } │ │ │ │ │ 143 │ │ │ │ │ -144 template class TransformedNodeTemplate> │ │ │ │ │ -_1_4_5 struct _T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -146 { │ │ │ │ │ -147 │ │ │ │ │ -_1_4_8 static const bool _r_e_c_u_r_s_i_v_e = true; │ │ │ │ │ -149 │ │ │ │ │ -150 template │ │ │ │ │ -_1_5_1 struct _r_e_s_u_l_t │ │ │ │ │ -152 { │ │ │ │ │ -_1_5_3 typedef typename TransformedNodeTemplate_:_:_t_y_p_e _t_y_p_e; │ │ │ │ │ -_1_5_4 typedef std::shared_ptr _s_t_o_r_a_g_e___t_y_p_e; │ │ │ │ │ -155 }; │ │ │ │ │ -156 │ │ │ │ │ -157 template │ │ │ │ │ -_1_5_8 static typename _r_e_s_u_l_t::type _t_r_a_n_s_f_o_r_m(const SourceNode& s, const │ │ │ │ │ -Transformation& t, std::shared_ptr... children) │ │ │ │ │ -159 { │ │ │ │ │ -160 return typename _r_e_s_u_l_t_<_T_C_._._._>_:_:_t_y_p_e(s,t,children...); │ │ │ │ │ -161 } │ │ │ │ │ -162 │ │ │ │ │ -163 template │ │ │ │ │ -_1_6_4 static typename _r_e_s_u_l_t::type _t_r_a_n_s_f_o_r_m(std::shared_ptr s, const Transformation& t, std::shared_ptr... children) │ │ │ │ │ -165 { │ │ │ │ │ -166 return typename _r_e_s_u_l_t_<_T_C_._._._>_:_:_t_y_p_e(s,t,children...); │ │ │ │ │ -167 } │ │ │ │ │ +145 │ │ │ │ │ +156 template │ │ │ │ │ +_1_5_7 class _H_y_b_r_i_d_T_r_e_e_P_a_t_h │ │ │ │ │ +158 { │ │ │ │ │ +159 │ │ │ │ │ +160 // enable check for dune-typetree 2.10 and above │ │ │ │ │ +161#if DUNE_VERSION_GTE(TYPETREE,2,10) │ │ │ │ │ +162 // make sure that all indices use std::size_t as the underlying number type │ │ │ │ │ +163 static_assert((... && Impl::check_size_t()), │ │ │ │ │ +164 "HybridTreePath index storage must be std::size_t or std:: │ │ │ │ │ +integral_constant"); │ │ │ │ │ +165#endif │ │ │ │ │ +166 │ │ │ │ │ +167 public: │ │ │ │ │ 168 │ │ │ │ │ -169 template │ │ │ │ │ -_1_7_0 static typename _r_e_s_u_l_t::storage_type _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std:: │ │ │ │ │ -shared_ptr s, const Transformation& t, std::shared_ptr... │ │ │ │ │ -children) │ │ │ │ │ -171 { │ │ │ │ │ -172 return std::make_shared::type>(s,t,children...); │ │ │ │ │ -173 } │ │ │ │ │ -174 │ │ │ │ │ -175 }; │ │ │ │ │ -176 │ │ │ │ │ -177 │ │ │ │ │ -178 template class TransformedNode> │ │ │ │ │ -_1_7_9 struct _G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -180 : public _T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n::template result │ │ │ │ │ -185 > │ │ │ │ │ -186 {}; │ │ │ │ │ -187 │ │ │ │ │ -189 │ │ │ │ │ -190 } // namespace TypeTree │ │ │ │ │ -191} //namespace Dune │ │ │ │ │ +_1_7_0 using _i_n_d_e_x___s_e_q_u_e_n_c_e = std::index_sequence_for; │ │ │ │ │ +171 │ │ │ │ │ +_1_7_3 constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h() │ │ │ │ │ +174 { │ │ │ │ │ +175 [[maybe_unused]] constexpr bool check = │ │ │ │ │ +176 (... && Impl::check_storage_type(MetaType()) ); │ │ │ │ │ +177 } │ │ │ │ │ +178 │ │ │ │ │ +_1_7_9 constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h& tp) = default; │ │ │ │ │ +_1_8_0 constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h(_H_y_b_r_i_d_T_r_e_e_P_a_t_h&& tp) = default; │ │ │ │ │ +181 │ │ │ │ │ +_1_8_2 constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h& _o_p_e_r_a_t_o_r_=(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h& tp) = default; │ │ │ │ │ +_1_8_3 constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h& _o_p_e_r_a_t_o_r_=(_H_y_b_r_i_d_T_r_e_e_P_a_t_h&& tp) = default; │ │ │ │ │ +184 │ │ │ │ │ +_1_8_6 explicit constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h(std::tuple t) │ │ │ │ │ +187 : _data(t) │ │ │ │ │ +188 { │ │ │ │ │ +189 [[maybe_unused]] constexpr bool check = │ │ │ │ │ +190 (... && Impl::check_storage_type(MetaType()) ); │ │ │ │ │ +191 } │ │ │ │ │ 192 │ │ │ │ │ -193#endif // DUNE_TYPETREE_GENERICTRANSFORMATIONDESCRIPTORS_HH │ │ │ │ │ -_p_o_w_e_r_c_o_m_p_o_s_i_t_e_n_o_d_e_t_r_a_n_s_f_o_r_m_a_t_i_o_n_t_e_m_p_l_a_t_e_s_._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 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_D_e_g_r_e_e │ │ │ │ │ -decltype(Node::degree()) StaticDegree │ │ │ │ │ -Returns the statically known degree of the given Node type as a std:: │ │ │ │ │ -integral_constant. │ │ │ │ │ -DDeeffiinniittiioonn nodeinterface.hh:107 │ │ │ │ │ +194 template 0 && sizeof...(U) == sizeof... │ │ │ │ │ +(T)),bool> = true> │ │ │ │ │ +_1_9_6 explicit constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h(U... t) │ │ │ │ │ +197 : _data(t...) // we assume that all arguments are convertible to the types │ │ │ │ │ +T... │ │ │ │ │ +198 { │ │ │ │ │ +199 [[maybe_unused]] constexpr bool check = │ │ │ │ │ +200 (... && Impl::check_storage_type(MetaType()) ); │ │ │ │ │ +201 } │ │ │ │ │ +202 │ │ │ │ │ +_2_0_4 [[nodiscard]] constexpr static _i_n_d_e_x___s_e_q_u_e_n_c_e _e_n_u_m_e_r_a_t_e() │ │ │ │ │ +205 { │ │ │ │ │ +206 return {}; │ │ │ │ │ +207 } │ │ │ │ │ +208 │ │ │ │ │ +_2_1_0 [[nodiscard]] constexpr static std::size_t _s_i_z_e() │ │ │ │ │ +211 { │ │ │ │ │ +212 return sizeof...(T); │ │ │ │ │ +213 } │ │ │ │ │ +214 │ │ │ │ │ +_2_1_6 [[nodiscard]] constexpr static std::size_t _m_a_x___s_i_z_e() │ │ │ │ │ +217 { │ │ │ │ │ +218 return _s_i_z_e(); │ │ │ │ │ +219 } │ │ │ │ │ +220 │ │ │ │ │ +222 template i),bool> = true> │ │ │ │ │ +_2_2_4 [[nodiscard]] constexpr auto _o_p_e_r_a_t_o_r_[_](Dune::index_constant) const │ │ │ │ │ +225 { │ │ │ │ │ +226 return std::get(_data); │ │ │ │ │ +227 } │ │ │ │ │ +228 │ │ │ │ │ +_2_3_0 [[nodiscard]] constexpr std::size_t _o_p_e_r_a_t_o_r_[_](std::size_t pos) const │ │ │ │ │ +231 { │ │ │ │ │ +232 std::size_t entry = 0; │ │ │ │ │ +233 Dune::Hybrid::forEach(_e_n_u_m_e_r_a_t_e(), [&] (auto i) { │ │ │ │ │ +234 if (i==pos) │ │ │ │ │ +235 entry = this->_e_l_e_m_e_n_t(i); │ │ │ │ │ +236 }); │ │ │ │ │ +237 return entry; │ │ │ │ │ +238 } │ │ │ │ │ +239 │ │ │ │ │ +241 template i),bool> = true> │ │ │ │ │ +_2_4_3 [[nodiscard]] constexpr auto _e_l_e_m_e_n_t(Dune::index_constant pos = {}) │ │ │ │ │ +const │ │ │ │ │ +244 { │ │ │ │ │ +245 return std::get(_data); │ │ │ │ │ +246 } │ │ │ │ │ +247 │ │ │ │ │ +_2_4_9 [[nodiscard]] constexpr std::size_t _e_l_e_m_e_n_t(std::size_t pos) const │ │ │ │ │ +250 { │ │ │ │ │ +251 std::size_t entry = 0; │ │ │ │ │ +252 Dune::Hybrid::forEach(_e_n_u_m_e_r_a_t_e(), [&] (auto i) { │ │ │ │ │ +253 if (i==pos) │ │ │ │ │ +254 entry = this->_e_l_e_m_e_n_t(i); │ │ │ │ │ +255 }); │ │ │ │ │ +256 return entry; │ │ │ │ │ +257 } │ │ │ │ │ +258 │ │ │ │ │ +260 template 0 && n == sizeof...(T)),bool> = true> │ │ │ │ │ +_2_6_2 [[nodiscard]] constexpr auto _f_r_o_n_t() const │ │ │ │ │ +263 { │ │ │ │ │ +264 return std::get<0>(_data); │ │ │ │ │ +265 } │ │ │ │ │ +266 │ │ │ │ │ +268 template 0 && n == sizeof...(T)),bool> = true> │ │ │ │ │ +_2_7_0 [[nodiscard]] constexpr auto _b_a_c_k() const │ │ │ │ │ +271 { │ │ │ │ │ +272 return std::get(_data); │ │ │ │ │ +273 } │ │ │ │ │ +274 │ │ │ │ │ +275#ifndef DOXYGEN │ │ │ │ │ +276 │ │ │ │ │ +277 // I can't be bothered to make all the external accessors friends of │ │ │ │ │ +HybridTreePath, │ │ │ │ │ +278 // so we'll only hide the data tuple from the user in Doxygen. │ │ │ │ │ +279 │ │ │ │ │ +280 using Data = std::tuple; │ │ │ │ │ +281 Data _data; │ │ │ │ │ +282 │ │ │ │ │ +283#endif // DOXYGEN │ │ │ │ │ +284 │ │ │ │ │ +285 }; │ │ │ │ │ +286 │ │ │ │ │ +288 │ │ │ │ │ +294 template │ │ │ │ │ +_2_9_5 [[nodiscard]] constexpr auto _m_a_k_e_T_r_e_e_P_a_t_h(const T... t) │ │ │ │ │ +296 { │ │ │ │ │ +297 // check that all entries are based on std::size_t │ │ │ │ │ +298 static_assert((... && Impl::check_size_t()), │ │ │ │ │ +299 "HybridTreePath indices must be of type std::size_t or std:: │ │ │ │ │ +integral_constant"); │ │ │ │ │ +300 return _H_y_b_r_i_d_T_r_e_e_P_a_t_h(t...); │ │ │ │ │ +301 } │ │ │ │ │ +302 │ │ │ │ │ +304 │ │ │ │ │ +311 template │ │ │ │ │ +_3_1_2 [[nodiscard]] constexpr auto _h_y_b_r_i_d_T_r_e_e_P_a_t_h(const T&... t) │ │ │ │ │ +313 { │ │ │ │ │ +314 return _m_a_k_e_T_r_e_e_P_a_t_h(Impl::cast_size_t(t)...); │ │ │ │ │ +315 } │ │ │ │ │ +316 │ │ │ │ │ +318 │ │ │ │ │ +325 template │ │ │ │ │ +_3_2_6 [[nodiscard]] constexpr auto _t_r_e_e_P_a_t_h(const T&... t) │ │ │ │ │ +327 { │ │ │ │ │ +328 return _m_a_k_e_T_r_e_e_P_a_t_h(Impl::cast_size_t(t)...); │ │ │ │ │ +329 } │ │ │ │ │ +330 │ │ │ │ │ +331 │ │ │ │ │ +333 template │ │ │ │ │ +_3_3_4 [[nodiscard]] constexpr std::size_t _t_r_e_e_P_a_t_h_S_i_z_e(const │ │ │ │ │ +_H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>&) │ │ │ │ │ +335 { │ │ │ │ │ +336 return sizeof...(T); │ │ │ │ │ +337 } │ │ │ │ │ +338 │ │ │ │ │ +340 │ │ │ │ │ +356 template │ │ │ │ │ +_3_5_7 [[nodiscard]] constexpr auto _t_r_e_e_P_a_t_h_E_n_t_r_y(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp, │ │ │ │ │ +index_constant = {}) │ │ │ │ │ +358 -> typename std::decay(tp._data))>::type │ │ │ │ │ +359 { │ │ │ │ │ +360 return std::get(tp._data); │ │ │ │ │ +361 } │ │ │ │ │ +362 │ │ │ │ │ +364 │ │ │ │ │ +379 template │ │ │ │ │ +_3_8_0 [[nodiscard]] constexpr std::size_t _t_r_e_e_P_a_t_h_I_n_d_e_x(const │ │ │ │ │ +_H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp, index_constant = {}) │ │ │ │ │ +381 { │ │ │ │ │ +382 return std::get(tp._data); │ │ │ │ │ +383 } │ │ │ │ │ +384 │ │ │ │ │ +386 │ │ │ │ │ +391 template │ │ │ │ │ +_3_9_2 [[nodiscard]] constexpr auto _b_a_c_k(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp) │ │ │ │ │ +393 -> decltype(tp._b_a_c_k()) │ │ │ │ │ +394 { │ │ │ │ │ +395 return tp._b_a_c_k(); │ │ │ │ │ +396 } │ │ │ │ │ +397 │ │ │ │ │ +399 │ │ │ │ │ +404 template │ │ │ │ │ +_4_0_5 [[nodiscard]] constexpr auto _f_r_o_n_t(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp) │ │ │ │ │ +406 -> decltype(tp._f_r_o_n_t()) │ │ │ │ │ +407 { │ │ │ │ │ +408 return tp._f_r_o_n_t(); │ │ │ │ │ +409 } │ │ │ │ │ +410 │ │ │ │ │ +412 │ │ │ │ │ +415 template │ │ │ │ │ +_4_1_6 [[nodiscard]] constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h _p_u_s_h___b_a_c_k(const │ │ │ │ │ +_H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp, std::size_t i) │ │ │ │ │ +417 { │ │ │ │ │ +418 return _H_y_b_r_i_d_T_r_e_e_P_a_t_h(std::tuple_cat(tp._data,std:: │ │ │ │ │ +make_tuple(i))); │ │ │ │ │ +419 } │ │ │ │ │ +420 │ │ │ │ │ +422 │ │ │ │ │ +436 template │ │ │ │ │ +_4_3_7 [[nodiscard]] constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h> _p_u_s_h___b_a_c_k │ │ │ │ │ +(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp, index_constant i_ = {}) │ │ │ │ │ +438 { │ │ │ │ │ +439 return HybridTreePath >(std::tuple_cat │ │ │ │ │ +(tp._data,std::make_tuple(i_))); │ │ │ │ │ +440 } │ │ │ │ │ +441 │ │ │ │ │ +443 │ │ │ │ │ +446 template │ │ │ │ │ +_4_4_7 [[nodiscard]] constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h _p_u_s_h___f_r_o_n_t(const │ │ │ │ │ +_H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp, std::size_t element) │ │ │ │ │ +448 { │ │ │ │ │ +449 return _H_y_b_r_i_d_T_r_e_e_P_a_t_h(std::tuple_cat(std::make_tuple │ │ │ │ │ +(element),tp._data)); │ │ │ │ │ +450 } │ │ │ │ │ +451 │ │ │ │ │ +453 │ │ │ │ │ +467 template │ │ │ │ │ +_4_6_8 [[nodiscard]] constexpr _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_i_n_d_e_x___c_o_n_s_t_a_n_t_<_i_>,T...> _p_u_s_h___f_r_o_n_t │ │ │ │ │ +(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp, index_constant _i = {}) │ │ │ │ │ +469 { │ │ │ │ │ +470 return HybridTreePath,T...>(std::tuple_cat(std:: │ │ │ │ │ +make_tuple(_i),tp._data)); │ │ │ │ │ +471 } │ │ │ │ │ +472 │ │ │ │ │ +474 │ │ │ │ │ +485 template │ │ │ │ │ +0),bool> = true> │ │ │ │ │ +_4_8_6 [[nodiscard]] constexpr auto _a_c_c_u_m_u_l_a_t_e___b_a_c_k(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& │ │ │ │ │ +tp, I i) { │ │ │ │ │ +487 using ::Dune::Hybrid::plus; │ │ │ │ │ +488 return _p_u_s_h___b_a_c_k(_p_o_p___b_a_c_k(tp), _p_l_u_s(_b_a_c_k(tp), i)); │ │ │ │ │ +489 } │ │ │ │ │ +490 │ │ │ │ │ +491 │ │ │ │ │ +493 │ │ │ │ │ +504 template │ │ │ │ │ +0),bool> = true> │ │ │ │ │ +_5_0_5 [[nodiscard]] constexpr auto _a_c_c_u_m_u_l_a_t_e___f_r_o_n_t(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& │ │ │ │ │ +tp, I i) { │ │ │ │ │ +506 using ::Dune::Hybrid::plus; │ │ │ │ │ +507 return _p_u_s_h___f_r_o_n_t(_p_o_p___f_r_o_n_t(tp), _p_l_u_s(_f_r_o_n_t(tp), i)); │ │ │ │ │ +508 } │ │ │ │ │ +509 │ │ │ │ │ +511 template │ │ │ │ │ +_5_1_2 [[nodiscard]] constexpr auto _j_o_i_n(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_H_e_a_d_._._._>& head, │ │ │ │ │ +const Other&... tail) { │ │ │ │ │ +513 return _T_y_p_e_T_r_e_e_:_:_H_y_b_r_i_d_T_r_e_e_P_a_t_h{std::tuple_cat(head._data, tail._data...)}; │ │ │ │ │ +514 } │ │ │ │ │ +515 │ │ │ │ │ +517 template │ │ │ │ │ +_5_1_8 [[nodiscard]] constexpr auto _r_e_v_e_r_s_e(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp) { │ │ │ │ │ +519 constexpr std::size_t size = sizeof...(T); │ │ │ │ │ +520 return unpackIntegerSequence([&](auto... i){ │ │ │ │ │ +521 return _t_r_e_e_P_a_t_h(tp[index_constant{}] ...); │ │ │ │ │ +522 }, std::make_index_sequence{}); │ │ │ │ │ +523 } │ │ │ │ │ +524 │ │ │ │ │ +526 │ │ │ │ │ +529 template 0),bool> = true> │ │ │ │ │ +_5_3_0 [[nodiscard]] constexpr auto _p_o_p___f_r_o_n_t(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp) │ │ │ │ │ +531 { │ │ │ │ │ +532 return unpackIntegerSequence([&](auto... i){ │ │ │ │ │ +533 return _H_y_b_r_i_d_T_r_e_e_P_a_t_h{std::make_tuple(std::get(tp._data)...)}; │ │ │ │ │ +534 }, std::make_index_sequence<(sizeof...(T) - 1)>{}); │ │ │ │ │ +535 } │ │ │ │ │ +536 │ │ │ │ │ +538 │ │ │ │ │ +541 template 0),bool> = true> │ │ │ │ │ +_5_4_2 [[nodiscard]] constexpr auto _p_o_p___b_a_c_k(const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp) │ │ │ │ │ +543 { │ │ │ │ │ +544 return unpackIntegerSequence([&](auto... i){ │ │ │ │ │ +545 return _H_y_b_r_i_d_T_r_e_e_P_a_t_h{std::make_tuple(std::get(tp._data)...)}; │ │ │ │ │ +546 }, std::make_index_sequence<(sizeof...(T) - 1)>{}); │ │ │ │ │ +547 } │ │ │ │ │ +548 │ │ │ │ │ +550 │ │ │ │ │ +558 template │ │ │ │ │ +_5_5_9 [[nodiscard]] constexpr bool _o_p_e_r_a_t_o_r_=_=( │ │ │ │ │ +560 const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_S_._._._>& lhs, │ │ │ │ │ +561 const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& rhs) │ │ │ │ │ +562 { │ │ │ │ │ +563 if constexpr (sizeof...(S) == sizeof...(T)) { │ │ │ │ │ +564 if constexpr ((Dune::IsInteroperable::value &&...)) { │ │ │ │ │ +565 return unpackIntegerSequence([&](auto... i){ │ │ │ │ │ +566 return ((std::get(lhs._data) == std::get(rhs._data)) &&...); │ │ │ │ │ +567 }, std::make_index_sequence<(sizeof...(S))>{}); │ │ │ │ │ +568 } else { │ │ │ │ │ +569 return false; │ │ │ │ │ +570 } │ │ │ │ │ +571 } else { │ │ │ │ │ +572 return false; │ │ │ │ │ +573 } │ │ │ │ │ +574 } │ │ │ │ │ +575 │ │ │ │ │ +577 │ │ │ │ │ +582 template │ │ │ │ │ +_5_8_3 [[nodiscard]] constexpr auto _o_p_e_r_a_t_o_r_=_=( │ │ │ │ │ +584 const _H_y_b_r_i_d_T_r_e_e_P_a_t_h...>&, │ │ │ │ │ +585 const _H_y_b_r_i_d_T_r_e_e_P_a_t_h...>&) │ │ │ │ │ +586 { │ │ │ │ │ +587 return std::bool_constant<_h_y_b_r_i_d_T_r_e_e_P_a_t_h(lhs...) == _h_y_b_r_i_d_T_r_e_e_P_a_t_h(rhs...)> │ │ │ │ │ +{}; │ │ │ │ │ +588 } │ │ │ │ │ +589 │ │ │ │ │ +590 │ │ │ │ │ +592 template │ │ │ │ │ +_5_9_3 [[nodiscard]] constexpr auto _o_p_e_r_a_t_o_r_!_=( │ │ │ │ │ +594 const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_S_._._._>& lhs, │ │ │ │ │ +595 const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& rhs) │ │ │ │ │ +596 { │ │ │ │ │ +597 return !(lhs == rhs); │ │ │ │ │ +598 } │ │ │ │ │ +599 │ │ │ │ │ +601 template │ │ │ │ │ +_6_0_2 [[nodiscard]] constexpr auto _o_p_e_r_a_t_o_r_!_=( │ │ │ │ │ +603 const _H_y_b_r_i_d_T_r_e_e_P_a_t_h...>&, │ │ │ │ │ +604 const _H_y_b_r_i_d_T_r_e_e_P_a_t_h...>&) │ │ │ │ │ +605 { │ │ │ │ │ +606 return std::bool_constant<_h_y_b_r_i_d_T_r_e_e_P_a_t_h(lhs...) != _h_y_b_r_i_d_T_r_e_e_P_a_t_h(rhs...)> │ │ │ │ │ +{}; │ │ │ │ │ +607 } │ │ │ │ │ +608 │ │ │ │ │ +609 │ │ │ │ │ +_6_1_0 inline namespace Literals { │ │ │ │ │ +611 │ │ │ │ │ +613 │ │ │ │ │ +617 template │ │ │ │ │ +_6_1_8 constexpr auto operator"" _tp() │ │ │ │ │ +619 { │ │ │ │ │ +620 using namespace Dune::Indices::Literals; │ │ │ │ │ +621 return _h_y_b_r_i_d_T_r_e_e_P_a_t_h(operator""_ic()); │ │ │ │ │ +622 } │ │ │ │ │ +623 │ │ │ │ │ +624 } // end namespace Literals │ │ │ │ │ +625 │ │ │ │ │ +626 │ │ │ │ │ +627 template │ │ │ │ │ +_6_2_8 struct _T_r_e_e_P_a_t_h_S_i_z_e<_H_y_b_r_i_d_T_r_e_e_P_a_t_h...> > │ │ │ │ │ +629 : public index_constant │ │ │ │ │ +630 {}; │ │ │ │ │ +631 │ │ │ │ │ +632 │ │ │ │ │ +633 template │ │ │ │ │ +_6_3_4 struct _T_r_e_e_P_a_t_h_P_u_s_h_B_a_c_k<_H_y_b_r_i_d_T_r_e_e_P_a_t_h...>,k> │ │ │ │ │ +635 { │ │ │ │ │ +_6_3_6 typedef _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_i_n_d_e_x___c_o_n_s_t_a_n_t_<_i_>...,index_constant> _t_y_p_e; │ │ │ │ │ +637 }; │ │ │ │ │ +638 │ │ │ │ │ +639 template │ │ │ │ │ +_6_4_0 struct _T_r_e_e_P_a_t_h_P_u_s_h_F_r_o_n_t<_H_y_b_r_i_d_T_r_e_e_P_a_t_h...>,k> │ │ │ │ │ +641 { │ │ │ │ │ +_6_4_2 typedef _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_i_n_d_e_x___c_o_n_s_t_a_n_t_<_k_>,index_constant...> _t_y_p_e; │ │ │ │ │ +643 }; │ │ │ │ │ +644 │ │ │ │ │ +645 template │ │ │ │ │ +_6_4_6 struct _T_r_e_e_P_a_t_h_B_a_c_k<_H_y_b_r_i_d_T_r_e_e_P_a_t_h>> │ │ │ │ │ +647 : public index_constant │ │ │ │ │ +648 {}; │ │ │ │ │ +649 │ │ │ │ │ +650 template │ │ │ │ │ +_6_5_1 struct │ │ │ │ │ +_T_r_e_e_P_a_t_h_B_a_c_k<_H_y_b_r_i_d_T_r_e_e_P_a_t_h,index_constant,index_constant...>> │ │ │ │ │ +652 : public │ │ │ │ │ +_T_r_e_e_P_a_t_h_B_a_c_k,index_constant...>> │ │ │ │ │ +653 {}; │ │ │ │ │ +654 │ │ │ │ │ +655 template │ │ │ │ │ +_6_5_6 struct │ │ │ │ │ +_T_r_e_e_P_a_t_h_F_r_o_n_t<_H_y_b_r_i_d_T_r_e_e_P_a_t_h,index_constant...>> │ │ │ │ │ +657 : public index_constant │ │ │ │ │ +658 {}; │ │ │ │ │ +659 │ │ │ │ │ +660 template │ │ │ │ │ +_6_6_1 struct _T_r_e_e_P_a_t_h_P_o_p_B_a_c_k<_H_y_b_r_i_d_T_r_e_e_P_a_t_h>,i...> │ │ │ │ │ +662 { │ │ │ │ │ +_6_6_3 typedef _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_i_n_d_e_x___c_o_n_s_t_a_n_t_<_i_>...> _t_y_p_e; │ │ │ │ │ +664 }; │ │ │ │ │ +665 │ │ │ │ │ +666 template │ │ │ │ │ +_6_7_0 struct │ │ │ │ │ +_T_r_e_e_P_a_t_h_P_o_p_B_a_c_k<_H_y_b_r_i_d_T_r_e_e_P_a_t_h,index_constant,index_constant...>,i...> │ │ │ │ │ +671 : public │ │ │ │ │ +_T_r_e_e_P_a_t_h_P_o_p_B_a_c_k,index_constant...>,i...,j> │ │ │ │ │ +672 {}; │ │ │ │ │ +673 │ │ │ │ │ +674 template │ │ │ │ │ +_6_7_5 struct │ │ │ │ │ +_T_r_e_e_P_a_t_h_P_o_p_F_r_o_n_t<_H_y_b_r_i_d_T_r_e_e_P_a_t_h,index_constant...> > │ │ │ │ │ +676 { │ │ │ │ │ +_6_7_7 typedef _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_i_n_d_e_x___c_o_n_s_t_a_n_t_<_i_>...> _t_y_p_e; │ │ │ │ │ +678 }; │ │ │ │ │ +679 │ │ │ │ │ +680 template │ │ │ │ │ +_6_8_1 struct │ │ │ │ │ +_T_r_e_e_P_a_t_h_C_o_n_c_a_t<_H_y_b_r_i_d_T_r_e_e_P_a_t_h...>,_H_y_b_r_i_d_T_r_e_e_P_a_t_h...> │ │ │ │ │ +> │ │ │ │ │ +682 { │ │ │ │ │ +_6_8_3 typedef _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_i_n_d_e_x___c_o_n_s_t_a_n_t_<_i_>...,index_constant...> _t_y_p_e; │ │ │ │ │ +684 }; │ │ │ │ │ +685 │ │ │ │ │ +686#ifndef DOXYGEN │ │ │ │ │ +687 │ │ │ │ │ +688 namespace impl { │ │ │ │ │ +689 │ │ │ │ │ +690 // end of recursion │ │ │ │ │ +691 template │ │ │ │ │ +692 typename std::enable_if< │ │ │ │ │ +693 (i == sizeof...(T)) │ │ │ │ │ +694 >::type │ │ │ │ │ +695 print_hybrid_tree_path(std::ostream& os, const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp, │ │ │ │ │ +index_constant _i) │ │ │ │ │ +696 {} │ │ │ │ │ +697 │ │ │ │ │ +698 // print current entry and recurse │ │ │ │ │ +699 template │ │ │ │ │ +700 typename std::enable_if< │ │ │ │ │ +701 (i < sizeof...(T)) │ │ │ │ │ +702 >::type │ │ │ │ │ +703 print_hybrid_tree_path(std::ostream& os, const HybridTreePath& tp, │ │ │ │ │ +index_constant _i) │ │ │ │ │ +704 { │ │ │ │ │ +705 os << _t_r_e_e_P_a_t_h_I_n_d_e_x(tp,_i) << " "; │ │ │ │ │ +706 print_hybrid_tree_path(os,tp,index_constant{}); │ │ │ │ │ +707 } │ │ │ │ │ +708 │ │ │ │ │ +709 } // namespace impl │ │ │ │ │ +710 │ │ │ │ │ +711#endif // DOXYGEN │ │ │ │ │ +712 │ │ │ │ │ +714 template │ │ │ │ │ +_7_1_5 std::ostream& _o_p_e_r_a_t_o_r_<_<(std::ostream& os, const _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_T_._._._>& tp) │ │ │ │ │ +716 { │ │ │ │ │ +717 os << "HybridTreePath< "; │ │ │ │ │ +718 impl::print_hybrid_tree_path(os, tp, index_constant<0>{}); │ │ │ │ │ +719 os << ">"; │ │ │ │ │ +720 return os; │ │ │ │ │ +721 } │ │ │ │ │ +722 │ │ │ │ │ +723 template │ │ │ │ │ +_7_2_4 using _S_t_a_t_i_c_T_r_e_e_P_a_t_h = _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_D_u_n_e_:_:_i_n_d_e_x___c_o_n_s_t_a_n_t_<_i_>...>; │ │ │ │ │ +725 │ │ │ │ │ +727 │ │ │ │ │ +728 } // namespace TypeTree │ │ │ │ │ +729} //namespace Dune │ │ │ │ │ +730 │ │ │ │ │ +731#endif // DUNE_TYPETREE_TREEPATH_HH │ │ │ │ │ +_f_i_x_e_d_c_a_p_a_c_i_t_y_s_t_a_c_k_._h_h │ │ │ │ │ +_u_t_i_l_i_t_y_._h_h │ │ │ │ │ +_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_:_:_o_p_e_r_a_t_o_r_<_< │ │ │ │ │ +std::ostream & operator<<(std::ostream &os, const HybridTreePath< T... > &tp) │ │ │ │ │ +Dumps a HybridTreePath to a stream. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:715 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_t_r_e_e_P_a_t_h_S_i_z_e │ │ │ │ │ +constexpr std::size_t treePathSize(const HybridTreePath< T... > &) │ │ │ │ │ +Returns the size (number of components) of the given HybridTreePath. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:334 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_b_a_c_k │ │ │ │ │ +constexpr auto back(const HybridTreePath< T... > &tp) -> decltype(tp.back()) │ │ │ │ │ +Returns a copy of the last element of the HybridTreePath. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:392 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_u_s_h___f_r_o_n_t │ │ │ │ │ +constexpr HybridTreePath< std::size_t, T... > push_front(const HybridTreePath< │ │ │ │ │ +T... > &tp, std::size_t element) │ │ │ │ │ +Prepends a run time index to a HybridTreePath. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:447 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_c_c_u_m_u_l_a_t_e___f_r_o_n_t │ │ │ │ │ +constexpr auto accumulate_front(const HybridTreePath< T... > &tp, I i) │ │ │ │ │ +Hybrid utility that accumulates to the front of a multi-index. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:505 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_o_p___f_r_o_n_t │ │ │ │ │ +constexpr auto pop_front(const HybridTreePath< T... > &tp) │ │ │ │ │ +Removes first index on a HybridTreePath. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:530 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_r_e_v_e_r_s_e │ │ │ │ │ +constexpr auto reverse(const HybridTreePath< T... > &tp) │ │ │ │ │ +Reverses the order of the elements in the path. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:518 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_c_c_u_m_u_l_a_t_e___b_a_c_k │ │ │ │ │ +constexpr auto accumulate_back(const HybridTreePath< T... > &tp, I i) │ │ │ │ │ +Hybrid utility that accumulates to the back of a multi-index. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:486 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_j_o_i_n │ │ │ │ │ +constexpr auto join(const HybridTreePath< Head... > &head, const Other &... │ │ │ │ │ +tail) │ │ │ │ │ +Join two tree paths into one. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:512 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_t_r_e_e_P_a_t_h_E_n_t_r_y │ │ │ │ │ +constexpr auto treePathEntry(const HybridTreePath< T... > &tp, index_constant< │ │ │ │ │ +i >={}) -> typename std::decay< decltype(std::get< i >(tp._data))>::type │ │ │ │ │ +Returns a copy of the i-th element of the HybridTreePath. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:357 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_o_p___b_a_c_k │ │ │ │ │ +constexpr auto pop_back(const HybridTreePath< T... > &tp) │ │ │ │ │ +Removes last index on a HybridTreePath. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:542 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_p_e_r_a_t_o_r_!_= │ │ │ │ │ +constexpr auto operator!=(const HybridTreePath< S... > &lhs, const │ │ │ │ │ +HybridTreePath< T... > &rhs) │ │ │ │ │ +Compare two HybridTreePaths for unequality. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:593 │ │ │ │ │ +_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 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_t_r_e_e_P_a_t_h_I_n_d_e_x │ │ │ │ │ +constexpr std::size_t treePathIndex(const HybridTreePath< T... > &tp, │ │ │ │ │ +index_constant< i >={}) │ │ │ │ │ +Returns the index value of the i-th element of the HybridTreePath. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:380 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_m_a_k_e_T_r_e_e_P_a_t_h │ │ │ │ │ +constexpr auto makeTreePath(const T... t) │ │ │ │ │ +helper function to construct a new HybridTreePath from the given indices. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:295 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_o_p_e_r_a_t_o_r_=_= │ │ │ │ │ +constexpr bool operator==(const HybridTreePath< S... > &lhs, const │ │ │ │ │ +HybridTreePath< T... > &rhs) │ │ │ │ │ +Compare two HybridTreePaths for value equality. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:559 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_r_i_n_t___t_r_e_e___p_a_t_h │ │ │ │ │ +void print_tree_path(std::ostream &os) │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:134 │ │ │ │ │ +_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_:_:_T_y_p_e_T_r_e_e_:_:_f_r_o_n_t │ │ │ │ │ +constexpr auto front(const HybridTreePath< T... > &tp) -> decltype(tp.front()) │ │ │ │ │ +Returns a copy of the first element of the HybridTreePath. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:405 │ │ │ │ │ _D_u_n_e │ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:28 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m_e_d___t_y_p_e │ │ │ │ │ -TransformedNode transformed_type │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:32 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m_e_d___s_t_o_r_a_g_e___t_y_p_e │ │ │ │ │ -std::shared_ptr< transformed_type > transformed_storage_type │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:33 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ -static transformed_type transform(std::shared_ptr< const SourceNode > s, const │ │ │ │ │ -Transformation &t) │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:40 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_c_u_r_s_i_v_e │ │ │ │ │ -static const bool recursive │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:30 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ -static transformed_storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ -SourceNode > s, const Transformation &t) │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:45 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ -static transformed_type transform(const SourceNode &s, const Transformation &t) │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:35 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:55 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ -static result< TC >::storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ -SourceNode > s, const Transformation &t, const std::array< std::shared_ptr< TC │ │ │ │ │ ->, result< TC >::degree > &children) │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:80 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_c_u_r_s_i_v_e │ │ │ │ │ -static const bool recursive │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:57 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ -static result< TC >::type transform(std::shared_ptr< const SourceNode > s, │ │ │ │ │ -const Transformation &t, const std::array< std::shared_ptr< TC >, result< TC │ │ │ │ │ ->::degree > &children) │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:74 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ -static result< TC >::type transform(const SourceNode &s, const Transformation │ │ │ │ │ -&t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children) │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:68 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:61 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_t_y_p_e │ │ │ │ │ -TransformedNodeTemplate< TC >::type type │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:62 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_d_e_g_r_e_e │ │ │ │ │ -static const std::size_t degree │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:64 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_s_t_o_r_a_g_e___t_y_p_e │ │ │ │ │ -std::shared_ptr< type > storage_type │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:63 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:96 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:101 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ -static result< TC >::type transform(std::shared_ptr< const SourceNode > s, │ │ │ │ │ -const Transformation &t, const std::vector< std::shared_ptr< TC > > &children) │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:119 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_c_u_r_s_i_v_e │ │ │ │ │ -static const bool recursive │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:103 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ -static result< TC >::type transform(const SourceNode &s, const Transformation │ │ │ │ │ -&t, const std::vector< std::shared_ptr< TC > > &children) │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:113 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_: │ │ │ │ │ -_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ -static result< TC >::storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ -SourceNode > s, const Transformation &t, const std::vector< std::shared_ptr< TC │ │ │ │ │ -> > &children) │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:125 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:107 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_t_y_p_e │ │ │ │ │ -TransformedNodeTemplate< TC >::type type │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:108 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_: │ │ │ │ │ -_s_t_o_r_a_g_e___t_y_p_e │ │ │ │ │ -std::shared_ptr< type > storage_type │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:109 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:141 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:146 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ -static result< TC... >::type transform(const SourceNode &s, const │ │ │ │ │ -Transformation &t, std::shared_ptr< TC >... children) │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:158 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_: │ │ │ │ │ -_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ -static result< TC... >::storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ -SourceNode > s, const Transformation &t, std::shared_ptr< TC >... children) │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:170 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ -static result< TC... >::type transform(std::shared_ptr< const SourceNode > s, │ │ │ │ │ -const Transformation &t, std::shared_ptr< TC >... children) │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:164 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_c_u_r_s_i_v_e │ │ │ │ │ -static const bool recursive │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:148 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:152 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_t_y_p_e │ │ │ │ │ -TransformedNodeTemplate< TC... >::type type │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:153 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_: │ │ │ │ │ -_s_t_o_r_a_g_e___t_y_p_e │ │ │ │ │ -std::shared_ptr< type > storage_type │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:154 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ -DDeeffiinniittiioonn generictransformationdescriptors.hh:186 │ │ │ │ │ +_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_:_:_f_u_l_l_y_S_t_a_t_i_c │ │ │ │ │ +@ fullyStatic │ │ │ │ │ +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 │ │ │ │ │ +_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_:_:_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_:_:_H_y_b_r_i_d_T_r_e_e_P_a_t_h_:_:_H_y_b_r_i_d_T_r_e_e_P_a_t_h │ │ │ │ │ +constexpr HybridTreePath(HybridTreePath &&tp)=default │ │ │ │ │ +_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_:_:_b_a_c_k │ │ │ │ │ +constexpr auto back() const │ │ │ │ │ +Get the last index value. Only available in non-empty paths. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:270 │ │ │ │ │ +_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_:_:_o_p_e_r_a_t_o_r_= │ │ │ │ │ +constexpr HybridTreePath & operator=(const HybridTreePath &tp)=default │ │ │ │ │ +_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_:_:_e_l_e_m_e_n_t │ │ │ │ │ +constexpr std::size_t element(std::size_t pos) const │ │ │ │ │ +Get the index value at position pos. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:249 │ │ │ │ │ +_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_:_:_H_y_b_r_i_d_T_r_e_e_P_a_t_h │ │ │ │ │ +constexpr HybridTreePath(std::tuple< T... > t) │ │ │ │ │ +Constructor from a std::tuple │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:186 │ │ │ │ │ +_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_:_:_o_p_e_r_a_t_o_r_= │ │ │ │ │ +constexpr HybridTreePath & operator=(HybridTreePath &&tp)=default │ │ │ │ │ +_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_:_:_H_y_b_r_i_d_T_r_e_e_P_a_t_h │ │ │ │ │ +constexpr HybridTreePath(U... t) │ │ │ │ │ +Constructor from arguments. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:196 │ │ │ │ │ +_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_:_:_H_y_b_r_i_d_T_r_e_e_P_a_t_h │ │ │ │ │ +constexpr HybridTreePath() │ │ │ │ │ +Default constructor. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:173 │ │ │ │ │ +_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_:_:_e_l_e_m_e_n_t │ │ │ │ │ +constexpr auto element(Dune::index_constant< i > pos={}) const │ │ │ │ │ +Get the last index value. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:243 │ │ │ │ │ +_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_:_:_s_i_z_e │ │ │ │ │ +static constexpr std::size_t size() │ │ │ │ │ +Get the size (length) of this path. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:210 │ │ │ │ │ +_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_:_:_o_p_e_r_a_t_o_r_[_] │ │ │ │ │ +constexpr auto operator[](Dune::index_constant< i >) const │ │ │ │ │ +Get the index value at position pos. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:224 │ │ │ │ │ +_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_:_:_f_r_o_n_t │ │ │ │ │ +constexpr auto front() const │ │ │ │ │ +Get the first index value. Only available in non-empty paths. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:262 │ │ │ │ │ +_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_:_:_e_n_u_m_e_r_a_t_e │ │ │ │ │ +static constexpr index_sequence enumerate() │ │ │ │ │ +Returns an index_sequence for enumerating the components of this │ │ │ │ │ +HybridTreePath. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:204 │ │ │ │ │ +_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_:_:_H_y_b_r_i_d_T_r_e_e_P_a_t_h │ │ │ │ │ +constexpr HybridTreePath(const HybridTreePath &tp)=default │ │ │ │ │ +_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_:_:_o_p_e_r_a_t_o_r_[_] │ │ │ │ │ +constexpr std::size_t operator[](std::size_t pos) const │ │ │ │ │ +Get the index value at position pos. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:230 │ │ │ │ │ +_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_:_:_m_a_x___s_i_z_e │ │ │ │ │ +static constexpr std::size_t max_size() │ │ │ │ │ +Get the size (length) of this path. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:216 │ │ │ │ │ +_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_:_:_i_n_d_e_x___s_e_q_u_e_n_c_e │ │ │ │ │ +std::index_sequence_for< T... > index_sequence │ │ │ │ │ +An index_sequence for the entries in this HybridTreePath. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:170 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_S_i_z_e │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:110 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_u_s_h_B_a_c_k │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:113 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_u_s_h_F_r_o_n_t │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:116 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_B_a_c_k │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:119 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_F_r_o_n_t │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:122 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_o_p_B_a_c_k │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:125 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_o_p_F_r_o_n_t │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:128 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_C_o_n_c_a_t │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:131 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_u_s_h_B_a_c_k_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i_ _>_._._._ _>_,_ _k │ │ │ │ │ +_>_:_:_t_y_p_e │ │ │ │ │ +HybridTreePath< index_constant< i >..., index_constant< k > > type │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:636 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_u_s_h_F_r_o_n_t_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i_ _>_._._._ _>_,_ _k │ │ │ │ │ +_>_:_:_t_y_p_e │ │ │ │ │ +HybridTreePath< index_constant< k >, index_constant< i >... > type │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:642 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_o_p_B_a_c_k_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _>_ _>_,_ _i_._._. │ │ │ │ │ +_>_:_:_t_y_p_e │ │ │ │ │ +HybridTreePath< index_constant< i >... > type │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:663 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_P_o_p_F_r_o_n_t_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _>_, │ │ │ │ │ +_i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i_ _>_._._._ _>_ _>_:_:_t_y_p_e │ │ │ │ │ +HybridTreePath< index_constant< i >... > type │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:677 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_t_h_C_o_n_c_a_t_<_ _H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _i_ _>_._._._ _>_, │ │ │ │ │ +_H_y_b_r_i_d_T_r_e_e_P_a_t_h_<_ _i_n_d_e_x___c_o_n_s_t_a_n_t_<_ _k_ _>_._._._ _>_ _>_:_:_t_y_p_e │ │ │ │ │ +HybridTreePath< index_constant< i >..., index_constant< k >... > type │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:683 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00065.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: pairtraversal.hh File Reference │ │ │ │ +dune-typetree: simpletransformationdescriptors.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -70,46 +70,50 @@ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    │ │ │ │ -Namespaces | │ │ │ │ -Functions
    │ │ │ │ -
    pairtraversal.hh File Reference
    │ │ │ │ +Classes | │ │ │ │ +Namespaces
    │ │ │ │ +
    simpletransformationdescriptors.hh File Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │ -
    #include <dune/common/std/type_traits.hh>
    │ │ │ │ -#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ -#include <dune/typetree/nodetags.hh>
    │ │ │ │ -#include <dune/typetree/treepath.hh>
    │ │ │ │ -#include <dune/typetree/visitor.hh>
    │ │ │ │ -#include <dune/typetree/traversal.hh>
    │ │ │ │ +
    #include <array>
    │ │ │ │ +#include <memory>
    │ │ │ │ +#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ +#include <dune/typetree/nodetags.hh>
    │ │ │ │ +#include <dune/common/exceptions.hh>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │ │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +

    │ │ │ │ +Classes

    struct  Dune::TypeTree::SimpleLeafNodeTransformation< SourceNode, Transformation, TransformedNode >
     
    struct  Dune::TypeTree::SimplePowerNodeTransformation< SourceNode, Transformation, TransformedNode >
     
    struct  Dune::TypeTree::SimplePowerNodeTransformation< SourceNode, Transformation, TransformedNode >::result< TC >
     
    struct  Dune::TypeTree::SimpleDynamicPowerNodeTransformation< SourceNode, Transformation, TransformedNode >
     
    struct  Dune::TypeTree::SimpleDynamicPowerNodeTransformation< SourceNode, Transformation, TransformedNode >::result< TC >
     
    struct  Dune::TypeTree::SimpleCompositeNodeTransformation< SourceNode, Transformation, TransformedNode >
     
    struct  Dune::TypeTree::SimpleCompositeNodeTransformation< SourceNode, Transformation, TransformedNode >::result< TC >
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ -

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
     
    namespace  Dune::TypeTree::Detail
     
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │

    │ │ │ │ -Functions

    template<class T1 , class T2 , class TreePath , class V , std::enable_if_t<(std::decay_t< T1 >::isLeaf or std::decay_t< T2 >::isLeaf), int > = 0>
    void Dune::TypeTree::Detail::applyToTreePair (T1 &&tree1, T2 &&tree2, TreePath treePath, V &&visitor)
     
    template<typename Tree1 , typename Tree2 , typename Visitor >
    void Dune::TypeTree::applyToTreePair (Tree1 &&tree1, Tree2 &&tree2, Visitor &&visitor)
     Apply visitor to a pair of TypeTrees.
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,35 +1,43 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -_N_a_m_e_s_p_a_c_e_s | _F_u_n_c_t_i_o_n_s │ │ │ │ │ -pairtraversal.hh File Reference │ │ │ │ │ -#include │ │ │ │ │ +_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s │ │ │ │ │ +simpletransformationdescriptors.hh File Reference │ │ │ │ │ +#include │ │ │ │ │ +#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_/_v_i_s_i_t_o_r_._h_h> │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_v_e_r_s_a_l_._h_h> │ │ │ │ │ +#include │ │ │ │ │ _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_:_:_S_i_m_p_l_e_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ + _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ + _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ + _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _>_:_:_r_e_s_u_l_t_<_ _T_C_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ + _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ + _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _>_:_:_r_e_s_u_l_t_<_ _T_C_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ + _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ + _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _>_:_:_r_e_s_u_l_t_<_ _T_C_ _> │ │ │ │ │ +  │ │ │ │ │ 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_:_:_D_e_t_a_i_l │ │ │ │ │ -  │ │ │ │ │ -FFuunnccttiioonnss │ │ │ │ │ -template::isLeaf or std::decay_t< T2 >::isLeaf), int > = 0> │ │ │ │ │ -void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_a_p_p_l_y_T_o_T_r_e_e_P_a_i_r (T1 &&tree1, T2 &&tree2, TreePath │ │ │ │ │ - _t_r_e_e_P_a_t_h, V &&visitor) │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ -void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_p_p_l_y_T_o_T_r_e_e_P_a_i_r (Tree1 &&tree1, Tree2 &&tree2, Visitor │ │ │ │ │ - &&visitor) │ │ │ │ │ -  Apply visitor to a pair of TypeTrees. │ │ │ │ │ -  │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00065_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: pairtraversal.hh Source File │ │ │ │ +dune-typetree: simpletransformationdescriptors.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,152 +74,209 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -
    pairtraversal.hh
    │ │ │ │ +
    simpletransformationdescriptors.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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_PAIRTRAVERSAL_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_PAIRTRAVERSAL_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_SIMPLETRANSFORMATIONDESCRIPTORS_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_SIMPLETRANSFORMATIONDESCRIPTORS_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <dune/common/std/type_traits.hh>
    │ │ │ │ -
    10
    │ │ │ │ -
    11#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ -
    12#include <dune/typetree/nodetags.hh>
    │ │ │ │ -
    13#include <dune/typetree/treepath.hh>
    │ │ │ │ -
    14#include <dune/typetree/visitor.hh>
    │ │ │ │ -
    15#include <dune/typetree/traversal.hh>
    │ │ │ │ +
    9#include <array>
    │ │ │ │ +
    10#include <memory>
    │ │ │ │ +
    11
    │ │ │ │ +
    12#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ +
    13#include <dune/typetree/nodetags.hh>
    │ │ │ │ +
    14#include <dune/common/exceptions.hh>
    │ │ │ │ +
    15
    │ │ │ │
    16
    │ │ │ │
    17namespace Dune {
    │ │ │ │
    18 namespace TypeTree {
    │ │ │ │
    19
    │ │ │ │ -
    │ │ │ │ -
    25 namespace Detail {
    │ │ │ │ -
    26
    │ │ │ │ -
    27 /* The signature is the same as for the public applyToTreePair
    │ │ │ │ -
    28 * function in Dune::Typtree, despite the additionally passed
    │ │ │ │ -
    29 * treePath argument. The path passed here is associated to
    │ │ │ │ -
    30 * the tree and the relative paths of the children (wrt. to tree)
    │ │ │ │ -
    31 * are appended to this. Hence the behavior of the public function
    │ │ │ │ -
    32 * is resembled by passing an empty treePath.
    │ │ │ │ -
    33 */
    │ │ │ │ -
    34
    │ │ │ │ -
    35 /*
    │ │ │ │ -
    36 * This is the overload for leaf traversal
    │ │ │ │ -
    37 */
    │ │ │ │ -
    38 template<class T1, class T2, class TreePath, class V,
    │ │ │ │ -
    39 std::enable_if_t<(std::decay_t<T1>::isLeaf or std::decay_t<T2>::isLeaf), int> = 0>
    │ │ │ │ -
    │ │ │ │ -
    40 void applyToTreePair(T1&& tree1, T2&& tree2, TreePath treePath, V&& visitor)
    │ │ │ │ -
    41 {
    │ │ │ │ -
    42 visitor.leaf(tree1, tree2, treePath);
    │ │ │ │ -
    43 }
    │ │ │ │ -
    │ │ │ │ -
    44
    │ │ │ │ -
    45 /*
    │ │ │ │ -
    46 * This is the general overload doing static child traversal.
    │ │ │ │ -
    47 */
    │ │ │ │ -
    48 template<class T1, class T2, class TreePath, class V,
    │ │ │ │ -
    49 std::enable_if_t<not(std::decay_t<T1>::isLeaf or std::decay_t<T2>::isLeaf), int> = 0>
    │ │ │ │ -
    50 void applyToTreePair(T1&& tree1, T2&& tree2, TreePath treePath, V&& visitor)
    │ │ │ │ -
    51 {
    │ │ │ │ -
    52 // Do we really want to take care for const-ness of the Tree
    │ │ │ │ -
    53 // when instanciating VisitChild below? I'd rather expect this:
    │ │ │ │ -
    54 // using Tree1 = std::decay_t<T1>;
    │ │ │ │ -
    55 // using Tree2 = std::decay_t<T2>;
    │ │ │ │ -
    56 // using Visitor = std::decay_t<V>;
    │ │ │ │ -
    57 using Tree1 = std::remove_reference_t<T1>;
    │ │ │ │ -
    58 using Tree2 = std::remove_reference_t<T2>;
    │ │ │ │ -
    59 using Visitor = std::remove_reference_t<V>;
    │ │ │ │ -
    60 visitor.pre(tree1, tree2, treePath);
    │ │ │ │ -
    61
    │ │ │ │ -
    62 // check which type of traversal is supported by the trees
    │ │ │ │ -
    63 using allowDynamicTraversal = std::conjunction<
    │ │ │ │ -
    64 Dune::Std::is_detected<DynamicTraversalConcept,Tree1>,
    │ │ │ │ -
    65 Dune::Std::is_detected<DynamicTraversalConcept,Tree2>>;
    │ │ │ │ -
    66 using allowStaticTraversal = std::conjunction<
    │ │ │ │ -
    67 Dune::Std::is_detected<StaticTraversalConcept,Tree1>,
    │ │ │ │ -
    68 Dune::Std::is_detected<StaticTraversalConcept,Tree2>>;
    │ │ │ │ -
    69
    │ │ │ │ -
    70 // both trees must support either dynamic or static traversal
    │ │ │ │ -
    71 static_assert(allowDynamicTraversal::value || allowStaticTraversal::value);
    │ │ │ │ +
    25 template<typename SourceNode, typename Transformation, typename TransformedNode>
    │ │ │ │ +
    │ │ │ │ +
    26 struct SimpleLeafNodeTransformation
    │ │ │ │ +
    27 {
    │ │ │ │ +
    28
    │ │ │ │ +
    29 static const bool recursive = false;
    │ │ │ │ +
    30
    │ │ │ │ +
    31 typedef TransformedNode transformed_type;
    │ │ │ │ +
    32 typedef std::shared_ptr<transformed_type> transformed_storage_type;
    │ │ │ │ +
    33
    │ │ │ │ +
    │ │ │ │ +
    34 static transformed_type transform(const SourceNode& s, const Transformation& t)
    │ │ │ │ +
    35 {
    │ │ │ │ +
    36 return transformed_type();
    │ │ │ │ +
    37 }
    │ │ │ │ +
    │ │ │ │ +
    38
    │ │ │ │ +
    │ │ │ │ +
    39 static transformed_storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t)
    │ │ │ │ +
    40 {
    │ │ │ │ +
    41 return std::make_shared<transformed_type>();
    │ │ │ │ +
    42 }
    │ │ │ │ +
    │ │ │ │ +
    43
    │ │ │ │ +
    44 };
    │ │ │ │ +
    │ │ │ │ +
    45
    │ │ │ │ +
    46
    │ │ │ │ +
    47 template<typename SourceNode, typename Transformation, template<typename Child, std::size_t> class TransformedNode>
    │ │ │ │ +
    │ │ │ │ +
    48 struct SimplePowerNodeTransformation
    │ │ │ │ +
    49 {
    │ │ │ │ +
    50
    │ │ │ │ +
    51 static const bool recursive = true;
    │ │ │ │ +
    52
    │ │ │ │ +
    53 template<typename TC>
    │ │ │ │ +
    │ │ │ │ +
    54 struct result
    │ │ │ │ +
    55 {
    │ │ │ │ +
    56 typedef TransformedNode<TC, StaticDegree<SourceNode>::value> type;
    │ │ │ │ +
    57 typedef std::shared_ptr<type> storage_type;
    │ │ │ │ +
    58 static const std::size_t degree = StaticDegree<type>::value;
    │ │ │ │ +
    59 };
    │ │ │ │ +
    │ │ │ │ +
    60
    │ │ │ │ +
    61 template<typename TC>
    │ │ │ │ +
    │ │ │ │ +
    62 static typename result<TC>::type transform(const SourceNode& s, const Transformation& t, const std::array<std::shared_ptr<TC>,result<TC>::degree>& children)
    │ │ │ │ +
    63 {
    │ │ │ │ +
    64 return typename result<TC>::type(children);
    │ │ │ │ +
    65 }
    │ │ │ │ +
    │ │ │ │ +
    66
    │ │ │ │ +
    67 template<typename TC>
    │ │ │ │ +
    │ │ │ │ +
    68 static typename result<TC>::storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t, const std::array<std::shared_ptr<TC>,result<TC>::degree>& children)
    │ │ │ │ +
    69 {
    │ │ │ │ +
    70 return std::make_shared<typename result<TC>::type>(children);
    │ │ │ │ +
    71 }
    │ │ │ │ +
    │ │ │ │
    72
    │ │ │ │ -
    73 // the visitor may specify preferred dynamic traversal
    │ │ │ │ -
    74 using preferDynamicTraversal = std::bool_constant<Visitor::treePathType == TreePathType::dynamic>;
    │ │ │ │ +
    73 };
    │ │ │ │ +
    │ │ │ │ +
    74
    │ │ │ │
    75
    │ │ │ │ -
    76 // create a dynamic or static index range
    │ │ │ │ -
    77 auto indices = [&]{
    │ │ │ │ -
    78 if constexpr(preferDynamicTraversal::value && allowDynamicTraversal::value)
    │ │ │ │ -
    79 return Dune::range(std::size_t(tree1.degree()));
    │ │ │ │ -
    80 else
    │ │ │ │ -
    81 return Dune::range(tree1.degree());
    │ │ │ │ -
    82 }();
    │ │ │ │ -
    83
    │ │ │ │ -
    84 if constexpr(allowDynamicTraversal::value || allowStaticTraversal::value) {
    │ │ │ │ -
    85 Dune::Hybrid::forEach(indices, [&](auto i) {
    │ │ │ │ -
    86 auto&& child1 = tree1.child(i);
    │ │ │ │ -
    87 auto&& child2 = tree2.child(i);
    │ │ │ │ -
    88 using Child1 = std::decay_t<decltype(child1)>;
    │ │ │ │ -
    89 using Child2 = std::decay_t<decltype(child2)>;
    │ │ │ │ -
    90
    │ │ │ │ -
    91 visitor.beforeChild(tree1, child1, tree2, child2, treePath, i);
    │ │ │ │ -
    92
    │ │ │ │ -
    93 // This requires that visitor.in(...) can always be instantiated,
    │ │ │ │ -
    94 // even if there's a single child only.
    │ │ │ │ -
    95 if (i>0)
    │ │ │ │ -
    96 visitor.in(tree1, tree2, treePath);
    │ │ │ │ -
    97
    │ │ │ │ -
    98 constexpr bool visitChild = Visitor::template VisitChild<Tree1,Child1,Tree2,Child2,TreePath>::value;
    │ │ │ │ -
    99 if constexpr(visitChild) {
    │ │ │ │ -
    100 auto childTreePath = Dune::TypeTree::push_back(treePath, i);
    │ │ │ │ -
    101 applyToTreePair(child1, child2, childTreePath, visitor);
    │ │ │ │ -
    102 }
    │ │ │ │ +
    76 template<typename SourceNode, typename Transformation, template<typename Child> class TransformedNode>
    │ │ │ │ +
    │ │ │ │ +
    77 struct SimpleDynamicPowerNodeTransformation
    │ │ │ │ +
    78 {
    │ │ │ │ +
    79
    │ │ │ │ +
    80 static const bool recursive = true;
    │ │ │ │ +
    81
    │ │ │ │ +
    82 template<typename TC>
    │ │ │ │ +
    │ │ │ │ +
    83 struct result
    │ │ │ │ +
    84 {
    │ │ │ │ +
    85 typedef TransformedNode<TC> type;
    │ │ │ │ +
    86 typedef std::shared_ptr<type> storage_type;
    │ │ │ │ +
    87 };
    │ │ │ │ +
    │ │ │ │ +
    88
    │ │ │ │ +
    89 template<typename TC>
    │ │ │ │ +
    │ │ │ │ +
    90 static typename result<TC>::type transform(const SourceNode& s, const Transformation& t, const std::vector<std::shared_ptr<TC>>& children)
    │ │ │ │ +
    91 {
    │ │ │ │ +
    92 return typename result<TC>::type(children);
    │ │ │ │ +
    93 }
    │ │ │ │ +
    │ │ │ │ +
    94
    │ │ │ │ +
    95 template<typename TC>
    │ │ │ │ +
    │ │ │ │ +
    96 static typename result<TC>::storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t, const std::vector<std::shared_ptr<TC>>& children)
    │ │ │ │ +
    97 {
    │ │ │ │ +
    98 return std::make_shared<typename result<TC>::type>(children);
    │ │ │ │ +
    99 }
    │ │ │ │ +
    │ │ │ │ +
    100
    │ │ │ │ +
    101 };
    │ │ │ │ +
    │ │ │ │ +
    102
    │ │ │ │
    103
    │ │ │ │ -
    104 visitor.afterChild(tree1, child1, tree2, child2, treePath, i);
    │ │ │ │ -
    105 });
    │ │ │ │ -
    106 }
    │ │ │ │ -
    107 visitor.post(tree1, tree2, treePath);
    │ │ │ │ -
    108 }
    │ │ │ │ +
    104 template<typename SourceNode, typename Transformation, template<typename...> class TransformedNode>
    │ │ │ │ +
    │ │ │ │ +
    105 struct SimpleCompositeNodeTransformation
    │ │ │ │ +
    106 {
    │ │ │ │ +
    107
    │ │ │ │ +
    108 static const bool recursive = true;
    │ │ │ │
    109
    │ │ │ │ -
    110 } // namespace Detail
    │ │ │ │ +
    110 template<typename... TC>
    │ │ │ │ +
    │ │ │ │ +
    111 struct result
    │ │ │ │ +
    112 {
    │ │ │ │ +
    113 typedef TransformedNode<TC...> type;
    │ │ │ │ +
    114 typedef std::shared_ptr<type> storage_type;
    │ │ │ │ +
    115 };
    │ │ │ │ +
    │ │ │ │ +
    116
    │ │ │ │ +
    117 template<typename... TC>
    │ │ │ │ +
    │ │ │ │ +
    118 static typename result<TC...>::type transform(const SourceNode& s, const Transformation& t, std::shared_ptr<TC>... children)
    │ │ │ │ +
    119 {
    │ │ │ │ +
    120 return typename result<TC...>::type(children...);
    │ │ │ │ +
    121 }
    │ │ │ │ +
    │ │ │ │ +
    122
    │ │ │ │ +
    123 template<typename... TC>
    │ │ │ │ +
    │ │ │ │ +
    124 static typename result<TC...>::storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t, std::shared_ptr<TC>... children)
    │ │ │ │ +
    125 {
    │ │ │ │ +
    126 return std::make_shared<typename result<TC...>::type>(children...);
    │ │ │ │ +
    127 }
    │ │ │ │
    │ │ │ │ -
    111
    │ │ │ │ -
    113
    │ │ │ │ -
    127 template<typename Tree1, typename Tree2, typename Visitor>
    │ │ │ │ -
    │ │ │ │ -
    128 void applyToTreePair(Tree1&& tree1, Tree2&& tree2, Visitor&& visitor)
    │ │ │ │ -
    129 {
    │ │ │ │ -
    130 Detail::applyToTreePair(tree1, tree2, hybridTreePath(), visitor);
    │ │ │ │ -
    131 }
    │ │ │ │ +
    128
    │ │ │ │ +
    129 };
    │ │ │ │
    │ │ │ │ +
    130
    │ │ │ │
    132
    │ │ │ │ -
    134
    │ │ │ │ -
    135 } // namespace TypeTree
    │ │ │ │ -
    136} //namespace Dune
    │ │ │ │ -
    137
    │ │ │ │ -
    138#endif // DUNE_TYPETREE_PAIRTRAVERSAL_HH
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::applyToTreePair
    void applyToTreePair(Tree1 &&tree1, Tree2 &&tree2, Visitor &&visitor)
    Apply visitor to a pair of TypeTrees.
    Definition pairtraversal.hh:128
    │ │ │ │ -
    Dune::TypeTree::push_back
    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
    │ │ │ │ -
    Dune::TypeTree::hybridTreePath
    constexpr auto hybridTreePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:312
    │ │ │ │ -
    Dune::TypeTree::treePath
    constexpr auto treePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:326
    │ │ │ │ +
    133 } // namespace TypeTree
    │ │ │ │ +
    134} //namespace Dune
    │ │ │ │ +
    135
    │ │ │ │ +
    136#endif // DUNE_TYPETREE_SIMPLETRANSFORMATIONDESCRIPTORS_HH
    │ │ │ │ + │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::StaticDegree
    decltype(Node::degree()) StaticDegree
    Returns the statically known degree of the given Node type as a std::integral_constant.
    Definition nodeinterface.hh:107
    │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::Detail::applyToTreePair
    void applyToTreePair(T1 &&tree1, T2 &&tree2, TreePath treePath, V &&visitor)
    Definition pairtraversal.hh:40
    │ │ │ │ +
    Dune::TypeTree::SimpleLeafNodeTransformation
    Definition simpletransformationdescriptors.hh:27
    │ │ │ │ +
    Dune::TypeTree::SimpleLeafNodeTransformation::transform
    static transformed_type transform(const SourceNode &s, const Transformation &t)
    Definition simpletransformationdescriptors.hh:34
    │ │ │ │ +
    Dune::TypeTree::SimpleLeafNodeTransformation::recursive
    static const bool recursive
    Definition simpletransformationdescriptors.hh:29
    │ │ │ │ +
    Dune::TypeTree::SimpleLeafNodeTransformation::transformed_storage_type
    std::shared_ptr< transformed_type > transformed_storage_type
    Definition simpletransformationdescriptors.hh:32
    │ │ │ │ +
    Dune::TypeTree::SimpleLeafNodeTransformation::transform_storage
    static transformed_storage_type transform_storage(std::shared_ptr< const SourceNode > s, const Transformation &t)
    Definition simpletransformationdescriptors.hh:39
    │ │ │ │ +
    Dune::TypeTree::SimpleLeafNodeTransformation::transformed_type
    TransformedNode transformed_type
    Definition simpletransformationdescriptors.hh:31
    │ │ │ │ +
    Dune::TypeTree::SimplePowerNodeTransformation
    Definition simpletransformationdescriptors.hh:49
    │ │ │ │ +
    Dune::TypeTree::SimplePowerNodeTransformation::transform_storage
    static result< TC >::storage_type transform_storage(std::shared_ptr< const SourceNode > s, const Transformation &t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children)
    Definition simpletransformationdescriptors.hh:68
    │ │ │ │ +
    Dune::TypeTree::SimplePowerNodeTransformation::recursive
    static const bool recursive
    Definition simpletransformationdescriptors.hh:51
    │ │ │ │ +
    Dune::TypeTree::SimplePowerNodeTransformation::transform
    static result< TC >::type transform(const SourceNode &s, const Transformation &t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children)
    Definition simpletransformationdescriptors.hh:62
    │ │ │ │ +
    Dune::TypeTree::SimplePowerNodeTransformation::result
    Definition simpletransformationdescriptors.hh:55
    │ │ │ │ +
    Dune::TypeTree::SimplePowerNodeTransformation::result::type
    TransformedNode< TC, StaticDegree< SourceNode >::value > type
    Definition simpletransformationdescriptors.hh:56
    │ │ │ │ +
    Dune::TypeTree::SimplePowerNodeTransformation::result::degree
    static const std::size_t degree
    Definition simpletransformationdescriptors.hh:58
    │ │ │ │ +
    Dune::TypeTree::SimplePowerNodeTransformation::result::storage_type
    std::shared_ptr< type > storage_type
    Definition simpletransformationdescriptors.hh:57
    │ │ │ │ +
    Dune::TypeTree::SimpleDynamicPowerNodeTransformation
    Definition simpletransformationdescriptors.hh:78
    │ │ │ │ +
    Dune::TypeTree::SimpleDynamicPowerNodeTransformation::recursive
    static const bool recursive
    Definition simpletransformationdescriptors.hh:80
    │ │ │ │ +
    Dune::TypeTree::SimpleDynamicPowerNodeTransformation::transform
    static result< TC >::type transform(const SourceNode &s, const Transformation &t, const std::vector< std::shared_ptr< TC > > &children)
    Definition simpletransformationdescriptors.hh:90
    │ │ │ │ +
    Dune::TypeTree::SimpleDynamicPowerNodeTransformation::transform_storage
    static result< TC >::storage_type transform_storage(std::shared_ptr< const SourceNode > s, const Transformation &t, const std::vector< std::shared_ptr< TC > > &children)
    Definition simpletransformationdescriptors.hh:96
    │ │ │ │ +
    Dune::TypeTree::SimpleDynamicPowerNodeTransformation::result
    Definition simpletransformationdescriptors.hh:84
    │ │ │ │ +
    Dune::TypeTree::SimpleDynamicPowerNodeTransformation::result::type
    TransformedNode< TC > type
    Definition simpletransformationdescriptors.hh:85
    │ │ │ │ +
    Dune::TypeTree::SimpleDynamicPowerNodeTransformation::result::storage_type
    std::shared_ptr< type > storage_type
    Definition simpletransformationdescriptors.hh:86
    │ │ │ │ +
    Dune::TypeTree::SimpleCompositeNodeTransformation
    Definition simpletransformationdescriptors.hh:106
    │ │ │ │ +
    Dune::TypeTree::SimpleCompositeNodeTransformation::recursive
    static const bool recursive
    Definition simpletransformationdescriptors.hh:108
    │ │ │ │ +
    Dune::TypeTree::SimpleCompositeNodeTransformation::transform_storage
    static result< TC... >::storage_type transform_storage(std::shared_ptr< const SourceNode > s, const Transformation &t, std::shared_ptr< TC >... children)
    Definition simpletransformationdescriptors.hh:124
    │ │ │ │ +
    Dune::TypeTree::SimpleCompositeNodeTransformation::transform
    static result< TC... >::type transform(const SourceNode &s, const Transformation &t, std::shared_ptr< TC >... children)
    Definition simpletransformationdescriptors.hh:118
    │ │ │ │ +
    Dune::TypeTree::SimpleCompositeNodeTransformation::result
    Definition simpletransformationdescriptors.hh:112
    │ │ │ │ +
    Dune::TypeTree::SimpleCompositeNodeTransformation::result::storage_type
    std::shared_ptr< type > storage_type
    Definition simpletransformationdescriptors.hh:114
    │ │ │ │ +
    Dune::TypeTree::SimpleCompositeNodeTransformation::result::type
    TransformedNode< TC... > type
    Definition simpletransformationdescriptors.hh:113
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,161 +1,253 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -pairtraversal.hh │ │ │ │ │ +simpletransformationdescriptors.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_PAIRTRAVERSAL_HH │ │ │ │ │ -7#define DUNE_TYPETREE_PAIRTRAVERSAL_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_SIMPLETRANSFORMATIONDESCRIPTORS_HH │ │ │ │ │ +7#define DUNE_TYPETREE_SIMPLETRANSFORMATIONDESCRIPTORS_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include │ │ │ │ │ -10 │ │ │ │ │ -11#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> │ │ │ │ │ -12#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ -13#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_e_e_p_a_t_h_._h_h> │ │ │ │ │ -14#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_v_i_s_i_t_o_r_._h_h> │ │ │ │ │ -15#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_a_v_e_r_s_a_l_._h_h> │ │ │ │ │ +9#include │ │ │ │ │ +10#include │ │ │ │ │ +11 │ │ │ │ │ +12#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> │ │ │ │ │ +13#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ +14#include │ │ │ │ │ +15 │ │ │ │ │ 16 │ │ │ │ │ 17namespace _D_u_n_e { │ │ │ │ │ 18 namespace TypeTree { │ │ │ │ │ 19 │ │ │ │ │ -_2_5 namespace Detail { │ │ │ │ │ -26 │ │ │ │ │ -27 /* The signature is the same as for the public applyToTreePair │ │ │ │ │ -28 * function in Dune::Typtree, despite the additionally passed │ │ │ │ │ -29 * treePath argument. The path passed here is associated to │ │ │ │ │ -30 * the tree and the relative paths of the children (wrt. to tree) │ │ │ │ │ -31 * are appended to this. Hence the behavior of the public function │ │ │ │ │ -32 * is resembled by passing an empty treePath. │ │ │ │ │ -33 */ │ │ │ │ │ -34 │ │ │ │ │ -35 /* │ │ │ │ │ -36 * This is the overload for leaf traversal │ │ │ │ │ -37 */ │ │ │ │ │ -38 template::isLeaf or std::decay_t::isLeaf), │ │ │ │ │ -int> = 0> │ │ │ │ │ -_4_0 void _a_p_p_l_y_T_o_T_r_e_e_P_a_i_r(T1&& tree1, T2&& tree2, TreePath _t_r_e_e_P_a_t_h, V&& visitor) │ │ │ │ │ -41 { │ │ │ │ │ -42 visitor.leaf(tree1, tree2, _t_r_e_e_P_a_t_h); │ │ │ │ │ -43 } │ │ │ │ │ -44 │ │ │ │ │ -45 /* │ │ │ │ │ -46 * This is the general overload doing static child traversal. │ │ │ │ │ -47 */ │ │ │ │ │ -48 template::isLeaf or std::decay_t::isLeaf), │ │ │ │ │ -int> = 0> │ │ │ │ │ -50 void _a_p_p_l_y_T_o_T_r_e_e_P_a_i_r(T1&& tree1, T2&& tree2, TreePath _t_r_e_e_P_a_t_h, V&& visitor) │ │ │ │ │ -51 { │ │ │ │ │ -52 // Do we really want to take care for const-ness of the Tree │ │ │ │ │ -53 // when instanciating VisitChild below? I'd rather expect this: │ │ │ │ │ -54 // using Tree1 = std::decay_t; │ │ │ │ │ -55 // using Tree2 = std::decay_t; │ │ │ │ │ -56 // using Visitor = std::decay_t; │ │ │ │ │ -57 using Tree1 = std::remove_reference_t; │ │ │ │ │ -58 using Tree2 = std::remove_reference_t; │ │ │ │ │ -59 using Visitor = std::remove_reference_t; │ │ │ │ │ -60 visitor.pre(tree1, tree2, _t_r_e_e_P_a_t_h); │ │ │ │ │ -61 │ │ │ │ │ -62 // check which type of traversal is supported by the trees │ │ │ │ │ -63 using allowDynamicTraversal = std::conjunction< │ │ │ │ │ -64 Dune::Std::is_detected, │ │ │ │ │ -65 Dune::Std::is_detected>; │ │ │ │ │ -66 using allowStaticTraversal = std::conjunction< │ │ │ │ │ -67 Dune::Std::is_detected, │ │ │ │ │ -68 Dune::Std::is_detected>; │ │ │ │ │ -69 │ │ │ │ │ -70 // both trees must support either dynamic or static traversal │ │ │ │ │ -71 static_assert(allowDynamicTraversal::value || allowStaticTraversal::value); │ │ │ │ │ +25 template │ │ │ │ │ +_2_6 struct _S_i_m_p_l_e_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +27 { │ │ │ │ │ +28 │ │ │ │ │ +_2_9 static const bool _r_e_c_u_r_s_i_v_e = false; │ │ │ │ │ +30 │ │ │ │ │ +_3_1 typedef TransformedNode _t_r_a_n_s_f_o_r_m_e_d___t_y_p_e; │ │ │ │ │ +_3_2 typedef std::shared_ptr _t_r_a_n_s_f_o_r_m_e_d___s_t_o_r_a_g_e___t_y_p_e; │ │ │ │ │ +33 │ │ │ │ │ +_3_4 static _t_r_a_n_s_f_o_r_m_e_d___t_y_p_e _t_r_a_n_s_f_o_r_m(const SourceNode& s, const Transformation& │ │ │ │ │ +t) │ │ │ │ │ +35 { │ │ │ │ │ +36 return _t_r_a_n_s_f_o_r_m_e_d___t_y_p_e(); │ │ │ │ │ +37 } │ │ │ │ │ +38 │ │ │ │ │ +_3_9 static _t_r_a_n_s_f_o_r_m_e_d___s_t_o_r_a_g_e___t_y_p_e _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std::shared_ptr s, const Transformation& t) │ │ │ │ │ +40 { │ │ │ │ │ +41 return std::make_shared(); │ │ │ │ │ +42 } │ │ │ │ │ +43 │ │ │ │ │ +44 }; │ │ │ │ │ +45 │ │ │ │ │ +46 │ │ │ │ │ +47 template class TransformedNode> │ │ │ │ │ +_4_8 struct _S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +49 { │ │ │ │ │ +50 │ │ │ │ │ +_5_1 static const bool _r_e_c_u_r_s_i_v_e = true; │ │ │ │ │ +52 │ │ │ │ │ +53 template │ │ │ │ │ +_5_4 struct _r_e_s_u_l_t │ │ │ │ │ +55 { │ │ │ │ │ +_5_6 typedef TransformedNode::value> _t_y_p_e; │ │ │ │ │ +_5_7 typedef std::shared_ptr _s_t_o_r_a_g_e___t_y_p_e; │ │ │ │ │ +_5_8 static const std::size_t _d_e_g_r_e_e = _S_t_a_t_i_c_D_e_g_r_e_e_<_t_y_p_e_>_:_:_v_a_l_u_e; │ │ │ │ │ +59 }; │ │ │ │ │ +60 │ │ │ │ │ +61 template │ │ │ │ │ +_6_2 static typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e _t_r_a_n_s_f_o_r_m(const SourceNode& s, const │ │ │ │ │ +Transformation& t, const std::array,_r_e_s_u_l_t_<_T_C_>_:_:_d_e_g_r_e_e>& │ │ │ │ │ +children) │ │ │ │ │ +63 { │ │ │ │ │ +64 return typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e(children); │ │ │ │ │ +65 } │ │ │ │ │ +66 │ │ │ │ │ +67 template │ │ │ │ │ +_6_8 static typename _r_e_s_u_l_t_<_T_C_>_:_:_s_t_o_r_a_g_e___t_y_p_e _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std:: │ │ │ │ │ +shared_ptr s, const Transformation& t, const std::array,_r_e_s_u_l_t_<_T_C_>_:_:_d_e_g_r_e_e>& children) │ │ │ │ │ +69 { │ │ │ │ │ +70 return std::make_shared::type>(children); │ │ │ │ │ +71 } │ │ │ │ │ 72 │ │ │ │ │ -73 // the visitor may specify preferred dynamic traversal │ │ │ │ │ -74 using preferDynamicTraversal = std::bool_constant; │ │ │ │ │ +73 }; │ │ │ │ │ +74 │ │ │ │ │ 75 │ │ │ │ │ -76 // create a dynamic or static index range │ │ │ │ │ -77 auto indices = [&]{ │ │ │ │ │ -78 if constexpr(preferDynamicTraversal::value && allowDynamicTraversal::value) │ │ │ │ │ -79 return Dune::range(std::size_t(tree1.degree())); │ │ │ │ │ -80 else │ │ │ │ │ -81 return Dune::range(tree1.degree()); │ │ │ │ │ -82 }(); │ │ │ │ │ -83 │ │ │ │ │ -84 if constexpr(allowDynamicTraversal::value || allowStaticTraversal::value) { │ │ │ │ │ -85 Dune::Hybrid::forEach(indices, [&](auto i) { │ │ │ │ │ -86 auto&& child1 = tree1.child(i); │ │ │ │ │ -87 auto&& child2 = tree2.child(i); │ │ │ │ │ -88 using Child1 = std::decay_t; │ │ │ │ │ -89 using Child2 = std::decay_t; │ │ │ │ │ -90 │ │ │ │ │ -91 visitor.beforeChild(tree1, child1, tree2, child2, _t_r_e_e_P_a_t_h, i); │ │ │ │ │ -92 │ │ │ │ │ -93 // This requires that visitor.in(...) can always be instantiated, │ │ │ │ │ -94 // even if there's a single child only. │ │ │ │ │ -95 if (i>0) │ │ │ │ │ -96 visitor.in(tree1, tree2, _t_r_e_e_P_a_t_h); │ │ │ │ │ -97 │ │ │ │ │ -98 constexpr bool visitChild = Visitor::template │ │ │ │ │ -VisitChild::value; │ │ │ │ │ -99 if constexpr(visitChild) { │ │ │ │ │ -100 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); │ │ │ │ │ -101 _a_p_p_l_y_T_o_T_r_e_e_P_a_i_r(child1, child2, childTreePath, visitor); │ │ │ │ │ -102 } │ │ │ │ │ +76 template class TransformedNode> │ │ │ │ │ +_7_7 struct _S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +78 { │ │ │ │ │ +79 │ │ │ │ │ +_8_0 static const bool _r_e_c_u_r_s_i_v_e = true; │ │ │ │ │ +81 │ │ │ │ │ +82 template │ │ │ │ │ +_8_3 struct _r_e_s_u_l_t │ │ │ │ │ +84 { │ │ │ │ │ +_8_5 typedef TransformedNode _t_y_p_e; │ │ │ │ │ +_8_6 typedef std::shared_ptr _s_t_o_r_a_g_e___t_y_p_e; │ │ │ │ │ +87 }; │ │ │ │ │ +88 │ │ │ │ │ +89 template │ │ │ │ │ +_9_0 static typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e _t_r_a_n_s_f_o_r_m(const SourceNode& s, const │ │ │ │ │ +Transformation& t, const std::vector>& children) │ │ │ │ │ +91 { │ │ │ │ │ +92 return typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e(children); │ │ │ │ │ +93 } │ │ │ │ │ +94 │ │ │ │ │ +95 template │ │ │ │ │ +_9_6 static typename _r_e_s_u_l_t_<_T_C_>_:_:_s_t_o_r_a_g_e___t_y_p_e _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std:: │ │ │ │ │ +shared_ptr s, const Transformation& t, const std:: │ │ │ │ │ +vector>& children) │ │ │ │ │ +97 { │ │ │ │ │ +98 return std::make_shared::type>(children); │ │ │ │ │ +99 } │ │ │ │ │ +100 │ │ │ │ │ +101 }; │ │ │ │ │ +102 │ │ │ │ │ 103 │ │ │ │ │ -104 visitor.afterChild(tree1, child1, tree2, child2, _t_r_e_e_P_a_t_h, i); │ │ │ │ │ -105 }); │ │ │ │ │ -106 } │ │ │ │ │ -107 visitor.post(tree1, tree2, _t_r_e_e_P_a_t_h); │ │ │ │ │ -108 } │ │ │ │ │ +104 template class TransformedNode> │ │ │ │ │ +_1_0_5 struct _S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +106 { │ │ │ │ │ +107 │ │ │ │ │ +_1_0_8 static const bool _r_e_c_u_r_s_i_v_e = true; │ │ │ │ │ 109 │ │ │ │ │ -110 } // namespace Detail │ │ │ │ │ -111 │ │ │ │ │ -113 │ │ │ │ │ -127 template │ │ │ │ │ -_1_2_8 void _a_p_p_l_y_T_o_T_r_e_e_P_a_i_r(Tree1&& tree1, Tree2&& tree2, Visitor&& visitor) │ │ │ │ │ -129 { │ │ │ │ │ -130 _D_e_t_a_i_l_:_:_a_p_p_l_y_T_o_T_r_e_e_P_a_i_r(tree1, tree2, _h_y_b_r_i_d_T_r_e_e_P_a_t_h(), visitor); │ │ │ │ │ -131 } │ │ │ │ │ +110 template │ │ │ │ │ +_1_1_1 struct _r_e_s_u_l_t │ │ │ │ │ +112 { │ │ │ │ │ +_1_1_3 typedef TransformedNode _t_y_p_e; │ │ │ │ │ +_1_1_4 typedef std::shared_ptr _s_t_o_r_a_g_e___t_y_p_e; │ │ │ │ │ +115 }; │ │ │ │ │ +116 │ │ │ │ │ +117 template │ │ │ │ │ +_1_1_8 static typename _r_e_s_u_l_t::type _t_r_a_n_s_f_o_r_m(const SourceNode& s, const │ │ │ │ │ +Transformation& t, std::shared_ptr... children) │ │ │ │ │ +119 { │ │ │ │ │ +120 return typename _r_e_s_u_l_t_<_T_C_._._._>_:_:_t_y_p_e(children...); │ │ │ │ │ +121 } │ │ │ │ │ +122 │ │ │ │ │ +123 template │ │ │ │ │ +_1_2_4 static typename _r_e_s_u_l_t::storage_type _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std:: │ │ │ │ │ +shared_ptr s, const Transformation& t, std::shared_ptr... │ │ │ │ │ +children) │ │ │ │ │ +125 { │ │ │ │ │ +126 return std::make_shared::type>(children...); │ │ │ │ │ +127 } │ │ │ │ │ +128 │ │ │ │ │ +129 }; │ │ │ │ │ +130 │ │ │ │ │ 132 │ │ │ │ │ -134 │ │ │ │ │ -135 } // namespace TypeTree │ │ │ │ │ -136} //namespace Dune │ │ │ │ │ -137 │ │ │ │ │ -138#endif // DUNE_TYPETREE_PAIRTRAVERSAL_HH │ │ │ │ │ -_v_i_s_i_t_o_r_._h_h │ │ │ │ │ -_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h │ │ │ │ │ -_t_r_e_e_p_a_t_h_._h_h │ │ │ │ │ +133 } // namespace TypeTree │ │ │ │ │ +134} //namespace Dune │ │ │ │ │ +135 │ │ │ │ │ +136#endif // DUNE_TYPETREE_SIMPLETRANSFORMATIONDESCRIPTORS_HH │ │ │ │ │ _n_o_d_e_t_a_g_s_._h_h │ │ │ │ │ -_t_r_a_v_e_r_s_a_l_._h_h │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_p_p_l_y_T_o_T_r_e_e_P_a_i_r │ │ │ │ │ -void applyToTreePair(Tree1 &&tree1, Tree2 &&tree2, Visitor &&visitor) │ │ │ │ │ -Apply visitor to a pair of TypeTrees. │ │ │ │ │ -DDeeffiinniittiioonn pairtraversal.hh:128 │ │ │ │ │ -_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 │ │ │ │ │ -_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 │ │ │ │ │ +_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_D_e_g_r_e_e │ │ │ │ │ +decltype(Node::degree()) StaticDegree │ │ │ │ │ +Returns the statically known degree of the given Node type as a std:: │ │ │ │ │ +integral_constant. │ │ │ │ │ +DDeeffiinniittiioonn nodeinterface.hh:107 │ │ │ │ │ _D_u_n_e │ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_a_p_p_l_y_T_o_T_r_e_e_P_a_i_r │ │ │ │ │ -void applyToTreePair(T1 &&tree1, T2 &&tree2, TreePath treePath, V &&visitor) │ │ │ │ │ -DDeeffiinniittiioonn pairtraversal.hh:40 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:27 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ +static transformed_type transform(const SourceNode &s, const Transformation &t) │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:34 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_c_u_r_s_i_v_e │ │ │ │ │ +static const bool recursive │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:29 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m_e_d___s_t_o_r_a_g_e___t_y_p_e │ │ │ │ │ +std::shared_ptr< transformed_type > transformed_storage_type │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:32 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ +static transformed_storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ +SourceNode > s, const Transformation &t) │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:39 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m_e_d___t_y_p_e │ │ │ │ │ +TransformedNode transformed_type │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:31 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:49 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ +static result< TC >::storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ +SourceNode > s, const Transformation &t, const std::array< std::shared_ptr< TC │ │ │ │ │ +>, result< TC >::degree > &children) │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:68 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_c_u_r_s_i_v_e │ │ │ │ │ +static const bool recursive │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:51 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ +static result< TC >::type transform(const SourceNode &s, const Transformation │ │ │ │ │ +&t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children) │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:62 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:55 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_t_y_p_e │ │ │ │ │ +TransformedNode< TC, StaticDegree< SourceNode >::value > type │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:56 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_d_e_g_r_e_e │ │ │ │ │ +static const std::size_t degree │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:58 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_s_t_o_r_a_g_e___t_y_p_e │ │ │ │ │ +std::shared_ptr< type > storage_type │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:57 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:78 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_c_u_r_s_i_v_e │ │ │ │ │ +static const bool recursive │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:80 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ +static result< TC >::type transform(const SourceNode &s, const Transformation │ │ │ │ │ +&t, const std::vector< std::shared_ptr< TC > > &children) │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:90 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ +static result< TC >::storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ +SourceNode > s, const Transformation &t, const std::vector< std::shared_ptr< TC │ │ │ │ │ +> > &children) │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:96 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:84 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_t_y_p_e │ │ │ │ │ +TransformedNode< TC > type │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:85 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_s_t_o_r_a_g_e___t_y_p_e │ │ │ │ │ +std::shared_ptr< type > storage_type │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:86 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:106 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_c_u_r_s_i_v_e │ │ │ │ │ +static const bool recursive │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:108 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ +static result< TC... >::storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ +SourceNode > s, const Transformation &t, std::shared_ptr< TC >... children) │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:124 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ +static result< TC... >::type transform(const SourceNode &s, const │ │ │ │ │ +Transformation &t, std::shared_ptr< TC >... children) │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:118 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:112 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_s_t_o_r_a_g_e___t_y_p_e │ │ │ │ │ +std::shared_ptr< type > storage_type │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:114 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_t_y_p_e │ │ │ │ │ +TransformedNode< TC... > type │ │ │ │ │ +DDeeffiinniittiioonn simpletransformationdescriptors.hh:113 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00068.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: leafnode.hh File Reference │ │ │ │ +dune-typetree: generictransformationdescriptors.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -72,27 +72,47 @@ │ │ │ │
  • dune
  • typetree
    • │ │ │ │
    │ │ │ │
    │ │ │ │
    │ │ │ │
    │ │ │ │ Classes | │ │ │ │ Namespaces
    │ │ │ │ -
    leafnode.hh File Reference
    │ │ │ │ +
    generictransformationdescriptors.hh File Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │ -
    #include <dune/typetree/nodetags.hh>
    │ │ │ │ -#include <cstddef>
    │ │ │ │ -#include <type_traits>
    │ │ │ │ +
    #include <array>
    │ │ │ │ +#include <memory>
    │ │ │ │ +#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ +#include <dune/typetree/nodetags.hh>
    │ │ │ │ +#include <dune/typetree/powercompositenodetransformationtemplates.hh>
    │ │ │ │ +#include <dune/common/exceptions.hh>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    class  Dune::TypeTree::LeafNode
     Base class for leaf nodes in a dune-typetree. More...
    struct  Dune::TypeTree::GenericLeafNodeTransformation< SourceNode, Transformation, TransformedNode >
     
    struct  Dune::TypeTree::TemplatizedGenericPowerNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate >
     
    struct  Dune::TypeTree::TemplatizedGenericPowerNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate >::result< TC >
     
    struct  Dune::TypeTree::GenericPowerNodeTransformation< SourceNode, Transformation, TransformedNode >
     
    struct  Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate >
     
    struct  Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate >::result< TC >
     
    struct  Dune::TypeTree::GenericDynamicPowerNodeTransformation< SourceNode, Transformation, TransformedNode >
     
    struct  Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate >
     
    struct  Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate >::result< TC >
     
    struct  Dune::TypeTree::GenericCompositeNodeTransformation< SourceNode, Transformation, TransformedNode >
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,22 +1,52 @@ │ │ │ │ │ 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 │ │ │ │ │ -leafnode.hh File Reference │ │ │ │ │ +generictransformationdescriptors.hh File Reference │ │ │ │ │ +#include │ │ │ │ │ +#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 │ │ │ │ │ -#include │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_p_o_w_e_r_c_o_m_p_o_s_i_t_e_n_o_d_e_t_r_a_n_s_f_o_r_m_a_t_i_o_n_t_e_m_p_l_a_t_e_s_._h_h> │ │ │ │ │ +#include │ │ │ │ │ _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 │ │ │ │ │ -class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e │ │ │ │ │ -  Base class for leaf nodes in a _d_u_n_e_-_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_:_:_G_e_n_e_r_i_c_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ + _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ + _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_T_e_m_p_l_a_t_e_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ + _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_T_e_m_p_l_a_t_e_ _>_:_:_r_e_s_u_l_t_<_ _T_C_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ + _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_< │ │ │ │ │ + _S_o_u_r_c_e_N_o_d_e_,_ _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_T_e_m_p_l_a_t_e_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_< │ │ │ │ │ + _S_o_u_r_c_e_N_o_d_e_,_ _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_T_e_m_p_l_a_t_e_ _>_:_:_r_e_s_u_l_t_<_ _T_C_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ + _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_< │ │ │ │ │ + _S_o_u_r_c_e_N_o_d_e_,_ _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_T_e_m_p_l_a_t_e_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_< │ │ │ │ │ + _S_o_u_r_c_e_N_o_d_e_,_ _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_T_e_m_p_l_a_t_e_ _>_:_:_r_e_s_u_l_t_<_ _T_C_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ + _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │   │ │ │ │ │ NNaammeessppaacceess │ │ │ │ │ namespace   _D_u_n_e │ │ │ │ │   │ │ │ │ │ namespace   _D_u_n_e_:_:_T_y_p_e_T_r_e_e │ │ │ │ │   │ │ │ │ │ =============================================================================== │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00068_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: leafnode.hh Source File │ │ │ │ +dune-typetree: generictransformationdescriptors.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,75 +74,288 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ -
    leafnode.hh
    │ │ │ │ +
    generictransformationdescriptors.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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_LEAFNODE_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_LEAFNODE_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_GENERICTRANSFORMATIONDESCRIPTORS_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_GENERICTRANSFORMATIONDESCRIPTORS_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <dune/typetree/nodetags.hh>
    │ │ │ │ -
    10#include <cstddef>
    │ │ │ │ -
    11#include <type_traits>
    │ │ │ │ -
    12
    │ │ │ │ -
    13namespace Dune {
    │ │ │ │ -
    14 namespace TypeTree {
    │ │ │ │ -
    15
    │ │ │ │ +
    9#include <array>
    │ │ │ │ +
    10#include <memory>
    │ │ │ │ +
    11
    │ │ │ │ +
    12#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ +
    13#include <dune/typetree/nodetags.hh>
    │ │ │ │ +
    14#include <dune/typetree/powercompositenodetransformationtemplates.hh>
    │ │ │ │ +
    15#include <dune/common/exceptions.hh>
    │ │ │ │ +
    16
    │ │ │ │ +
    17
    │ │ │ │ +
    18namespace Dune {
    │ │ │ │ +
    19 namespace TypeTree {
    │ │ │ │ +
    20
    │ │ │ │ +
    26 template<typename SourceNode, typename Transformation, typename TransformedNode>
    │ │ │ │
    │ │ │ │ -
    27 class LeafNode
    │ │ │ │ +
    27 struct GenericLeafNodeTransformation
    │ │ │ │
    28 {
    │ │ │ │
    29
    │ │ │ │ -
    30 public:
    │ │ │ │ +
    30 static const bool recursive = false;
    │ │ │ │
    31
    │ │ │ │ -
    33 static const bool isLeaf = true;
    │ │ │ │ +
    32 typedef TransformedNode transformed_type;
    │ │ │ │ +
    33 typedef std::shared_ptr<transformed_type> transformed_storage_type;
    │ │ │ │
    34
    │ │ │ │ -
    36 static const bool isPower = false;
    │ │ │ │ -
    37
    │ │ │ │ -
    39 static const bool isComposite = false;
    │ │ │ │ -
    40
    │ │ │ │ -
    42 typedef LeafNodeTag NodeTag;
    │ │ │ │ -
    43
    │ │ │ │ -
    │ │ │ │ -
    44 static constexpr auto degree()
    │ │ │ │ -
    45 {
    │ │ │ │ -
    46 return std::integral_constant<std::size_t,0>{};
    │ │ │ │ -
    47 }
    │ │ │ │ -
    │ │ │ │ -
    48
    │ │ │ │ -
    49 protected:
    │ │ │ │ -
    50
    │ │ │ │ +
    │ │ │ │ +
    35 static transformed_type transform(const SourceNode& s, const Transformation& t)
    │ │ │ │ +
    36 {
    │ │ │ │ +
    37 return transformed_type(s,t);
    │ │ │ │ +
    38 }
    │ │ │ │ +
    │ │ │ │ +
    39
    │ │ │ │ +
    │ │ │ │ +
    40 static transformed_type transform(std::shared_ptr<const SourceNode> s, const Transformation& t)
    │ │ │ │ +
    41 {
    │ │ │ │ +
    42 return transformed_type(s,t);
    │ │ │ │ +
    43 }
    │ │ │ │ +
    │ │ │ │ +
    44
    │ │ │ │ +
    │ │ │ │ +
    45 static transformed_storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t)
    │ │ │ │ +
    46 {
    │ │ │ │ +
    47 return std::make_shared<transformed_type>(s,t);
    │ │ │ │ +
    48 }
    │ │ │ │ +
    │ │ │ │ +
    49
    │ │ │ │ +
    50 };
    │ │ │ │ +
    │ │ │ │ +
    51
    │ │ │ │
    52
    │ │ │ │ -
    57 LeafNode() {}
    │ │ │ │ -
    58 };
    │ │ │ │ +
    53 template<typename SourceNode, typename Transformation, template<typename Child> class TransformedNodeTemplate>
    │ │ │ │ +
    │ │ │ │ +
    54 struct TemplatizedGenericPowerNodeTransformation
    │ │ │ │ +
    55 {
    │ │ │ │ +
    56
    │ │ │ │ +
    57 static const bool recursive = true;
    │ │ │ │ +
    58
    │ │ │ │ +
    59 template<typename TC>
    │ │ │ │ +
    │ │ │ │ +
    60 struct result
    │ │ │ │ +
    61 {
    │ │ │ │ +
    62 typedef typename TransformedNodeTemplate<TC>::type type;
    │ │ │ │ +
    63 typedef std::shared_ptr<type> storage_type;
    │ │ │ │ +
    64 static const std::size_t degree = StaticDegree<type>::value;
    │ │ │ │ +
    65 };
    │ │ │ │ +
    │ │ │ │ +
    66
    │ │ │ │ +
    67 template<typename TC>
    │ │ │ │ +
    │ │ │ │ +
    68 static typename result<TC>::type transform(const SourceNode& s, const Transformation& t, const std::array<std::shared_ptr<TC>,result<TC>::degree>& children)
    │ │ │ │ +
    69 {
    │ │ │ │ +
    70 return typename result<TC>::type(s,t,children);
    │ │ │ │ +
    71 }
    │ │ │ │ +
    │ │ │ │ +
    72
    │ │ │ │ +
    73 template<typename TC>
    │ │ │ │ +
    │ │ │ │ +
    74 static typename result<TC>::type transform(std::shared_ptr<const SourceNode> s, const Transformation& t, const std::array<std::shared_ptr<TC>,result<TC>::degree>& children)
    │ │ │ │ +
    75 {
    │ │ │ │ +
    76 return typename result<TC>::type(s,t,children);
    │ │ │ │ +
    77 }
    │ │ │ │ +
    │ │ │ │ +
    78
    │ │ │ │ +
    79 template<typename TC>
    │ │ │ │ +
    │ │ │ │ +
    80 static typename result<TC>::storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t, const std::array<std::shared_ptr<TC>,result<TC>::degree>& children)
    │ │ │ │ +
    81 {
    │ │ │ │ +
    82 return std::make_shared<typename result<TC>::type>(s,t,children);
    │ │ │ │ +
    83 }
    │ │ │ │ +
    │ │ │ │ +
    84
    │ │ │ │ +
    85 };
    │ │ │ │ +
    │ │ │ │ +
    86
    │ │ │ │ +
    87
    │ │ │ │ +
    88 template<typename SourceNode, typename Transformation, template<typename,typename,std::size_t> class TransformedNode>
    │ │ │ │ +
    │ │ │ │ +
    89 struct GenericPowerNodeTransformation
    │ │ │ │ +
    90 : public TemplatizedGenericPowerNodeTransformation<SourceNode,
    │ │ │ │ +
    91 Transformation,
    │ │ │ │ +
    92 GenericPowerNodeTransformationTemplate<SourceNode,
    │ │ │ │ +
    93 Transformation,
    │ │ │ │ +
    94 TransformedNode>::template result
    │ │ │ │ +
    95 >
    │ │ │ │ +
    96 {};
    │ │ │ │ +
    │ │ │ │ +
    97
    │ │ │ │ +
    98
    │ │ │ │ +
    99 template<typename SourceNode, typename Transformation, template<typename Child> class TransformedNodeTemplate>
    │ │ │ │ +
    │ │ │ │ +
    100 struct TemplatizedGenericDynamicPowerNodeTransformation
    │ │ │ │ +
    101 {
    │ │ │ │ +
    102
    │ │ │ │ +
    103 static const bool recursive = true;
    │ │ │ │ +
    104
    │ │ │ │ +
    105 template<typename TC>
    │ │ │ │ +
    │ │ │ │ +
    106 struct result
    │ │ │ │ +
    107 {
    │ │ │ │ +
    108 typedef typename TransformedNodeTemplate<TC>::type type;
    │ │ │ │ +
    109 typedef std::shared_ptr<type> storage_type;
    │ │ │ │ +
    110 };
    │ │ │ │ +
    │ │ │ │ +
    111
    │ │ │ │ +
    112 template<typename TC>
    │ │ │ │ +
    │ │ │ │ +
    113 static typename result<TC>::type transform(const SourceNode& s, const Transformation& t, const std::vector<std::shared_ptr<TC>>& children)
    │ │ │ │ +
    114 {
    │ │ │ │ +
    115 return typename result<TC>::type(s,t,children);
    │ │ │ │ +
    116 }
    │ │ │ │ +
    │ │ │ │ +
    117
    │ │ │ │ +
    118 template<typename TC>
    │ │ │ │ +
    │ │ │ │ +
    119 static typename result<TC>::type transform(std::shared_ptr<const SourceNode> s, const Transformation& t, const std::vector<std::shared_ptr<TC>>& children)
    │ │ │ │ +
    120 {
    │ │ │ │ +
    121 return typename result<TC>::type(s,t,children);
    │ │ │ │ +
    122 }
    │ │ │ │ +
    │ │ │ │ +
    123
    │ │ │ │ +
    124 template<typename TC>
    │ │ │ │ +
    │ │ │ │ +
    125 static typename result<TC>::storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t, const std::vector<std::shared_ptr<TC>>& children)
    │ │ │ │ +
    126 {
    │ │ │ │ +
    127 return std::make_shared<typename result<TC>::type>(s,t,children);
    │ │ │ │ +
    128 }
    │ │ │ │ +
    │ │ │ │ +
    129
    │ │ │ │ +
    130 };
    │ │ │ │ +
    │ │ │ │ +
    131
    │ │ │ │ +
    132
    │ │ │ │ +
    133 template<typename SourceNode, typename Transformation, template<typename,typename> class TransformedNode>
    │ │ │ │ +
    │ │ │ │ +
    134 struct GenericDynamicPowerNodeTransformation
    │ │ │ │ +
    135 : public TemplatizedGenericDynamicPowerNodeTransformation<SourceNode,
    │ │ │ │ +
    136 Transformation,
    │ │ │ │ +
    137 GenericDynamicPowerNodeTransformationTemplate<SourceNode,
    │ │ │ │ +
    138 Transformation,
    │ │ │ │ +
    139 TransformedNode>::template result
    │ │ │ │ +
    140 >
    │ │ │ │ +
    141 {};
    │ │ │ │ +
    │ │ │ │ +
    142
    │ │ │ │ +
    143
    │ │ │ │ +
    144 template<typename SourceNode, typename Transformation, template<typename...> class TransformedNodeTemplate>
    │ │ │ │ +
    │ │ │ │ +
    145 struct TemplatizedGenericCompositeNodeTransformation
    │ │ │ │ +
    146 {
    │ │ │ │ +
    147
    │ │ │ │ +
    148 static const bool recursive = true;
    │ │ │ │ +
    149
    │ │ │ │ +
    150 template<typename... TC>
    │ │ │ │ +
    │ │ │ │ +
    151 struct result
    │ │ │ │ +
    152 {
    │ │ │ │ +
    153 typedef typename TransformedNodeTemplate<TC...>::type type;
    │ │ │ │ +
    154 typedef std::shared_ptr<type> storage_type;
    │ │ │ │ +
    155 };
    │ │ │ │ +
    │ │ │ │ +
    156
    │ │ │ │ +
    157 template<typename... TC>
    │ │ │ │ +
    │ │ │ │ +
    158 static typename result<TC...>::type transform(const SourceNode& s, const Transformation& t, std::shared_ptr<TC>... children)
    │ │ │ │ +
    159 {
    │ │ │ │ +
    160 return typename result<TC...>::type(s,t,children...);
    │ │ │ │ +
    161 }
    │ │ │ │ +
    │ │ │ │ +
    162
    │ │ │ │ +
    163 template<typename... TC>
    │ │ │ │ +
    │ │ │ │ +
    164 static typename result<TC...>::type transform(std::shared_ptr<const SourceNode> s, const Transformation& t, std::shared_ptr<TC>... children)
    │ │ │ │ +
    165 {
    │ │ │ │ +
    166 return typename result<TC...>::type(s,t,children...);
    │ │ │ │ +
    167 }
    │ │ │ │ +
    │ │ │ │ +
    168
    │ │ │ │ +
    169 template<typename... TC>
    │ │ │ │ +
    │ │ │ │ +
    170 static typename result<TC...>::storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t, std::shared_ptr<TC>... children)
    │ │ │ │ +
    171 {
    │ │ │ │ +
    172 return std::make_shared<typename result<TC...>::type>(s,t,children...);
    │ │ │ │ +
    173 }
    │ │ │ │ +
    │ │ │ │ +
    174
    │ │ │ │ +
    175 };
    │ │ │ │ +
    │ │ │ │ +
    176
    │ │ │ │ +
    177
    │ │ │ │ +
    178 template<typename SourceNode, typename Transformation, template<typename,typename...> class TransformedNode>
    │ │ │ │ +
    │ │ │ │ +
    179 struct GenericCompositeNodeTransformation
    │ │ │ │ +
    180 : public TemplatizedGenericCompositeNodeTransformation<SourceNode,
    │ │ │ │ +
    181 Transformation,
    │ │ │ │ +
    182 GenericCompositeNodeTransformationTemplate<SourceNode,
    │ │ │ │ +
    183 Transformation,
    │ │ │ │ +
    184 TransformedNode>::template result
    │ │ │ │ +
    185 >
    │ │ │ │ +
    186 {};
    │ │ │ │
    │ │ │ │ -
    59
    │ │ │ │ -
    61
    │ │ │ │ -
    62 } // namespace TypeTree
    │ │ │ │ -
    63} //namespace Dune
    │ │ │ │ -
    64
    │ │ │ │ -
    65#endif // DUNE_TYPETREE_POWERNODE_HH
    │ │ │ │ - │ │ │ │ +
    187
    │ │ │ │ +
    189
    │ │ │ │ +
    190 } // namespace TypeTree
    │ │ │ │ +
    191} //namespace Dune
    │ │ │ │ +
    192
    │ │ │ │ +
    193#endif // DUNE_TYPETREE_GENERICTRANSFORMATIONDESCRIPTORS_HH
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::StaticDegree
    decltype(Node::degree()) StaticDegree
    Returns the statically known degree of the given Node type as a std::integral_constant.
    Definition nodeinterface.hh:107
    │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::LeafNode
    Base class for leaf nodes in a dune-typetree.
    Definition leafnode.hh:28
    │ │ │ │ -
    Dune::TypeTree::LeafNode::NodeTag
    LeafNodeTag NodeTag
    The type tag that describes a LeafNode.
    Definition leafnode.hh:42
    │ │ │ │ -
    Dune::TypeTree::LeafNode::isLeaf
    static const bool isLeaf
    Mark this class as a leaf in a dune-typetree.
    Definition leafnode.hh:33
    │ │ │ │ -
    Dune::TypeTree::LeafNode::isPower
    static const bool isPower
    Mark this class as a non power in the dune-typetree.
    Definition leafnode.hh:36
    │ │ │ │ -
    Dune::TypeTree::LeafNode::LeafNode
    LeafNode()
    Default constructor.
    Definition leafnode.hh:57
    │ │ │ │ -
    Dune::TypeTree::LeafNode::isComposite
    static const bool isComposite
    Mark this class as a non composite in the dune-typetree.
    Definition leafnode.hh:39
    │ │ │ │ -
    Dune::TypeTree::LeafNode::degree
    static constexpr auto degree()
    Definition leafnode.hh:44
    │ │ │ │ -
    Dune::TypeTree::LeafNodeTag
    Tag designating a leaf node.
    Definition nodetags.hh:18
    │ │ │ │ +
    Dune::TypeTree::GenericLeafNodeTransformation
    Definition generictransformationdescriptors.hh:28
    │ │ │ │ +
    Dune::TypeTree::GenericLeafNodeTransformation::transformed_type
    TransformedNode transformed_type
    Definition generictransformationdescriptors.hh:32
    │ │ │ │ +
    Dune::TypeTree::GenericLeafNodeTransformation::transformed_storage_type
    std::shared_ptr< transformed_type > transformed_storage_type
    Definition generictransformationdescriptors.hh:33
    │ │ │ │ +
    Dune::TypeTree::GenericLeafNodeTransformation::transform
    static transformed_type transform(std::shared_ptr< const SourceNode > s, const Transformation &t)
    Definition generictransformationdescriptors.hh:40
    │ │ │ │ +
    Dune::TypeTree::GenericLeafNodeTransformation::recursive
    static const bool recursive
    Definition generictransformationdescriptors.hh:30
    │ │ │ │ +
    Dune::TypeTree::GenericLeafNodeTransformation::transform_storage
    static transformed_storage_type transform_storage(std::shared_ptr< const SourceNode > s, const Transformation &t)
    Definition generictransformationdescriptors.hh:45
    │ │ │ │ +
    Dune::TypeTree::GenericLeafNodeTransformation::transform
    static transformed_type transform(const SourceNode &s, const Transformation &t)
    Definition generictransformationdescriptors.hh:35
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation
    Definition generictransformationdescriptors.hh:55
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation::transform_storage
    static result< TC >::storage_type transform_storage(std::shared_ptr< const SourceNode > s, const Transformation &t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children)
    Definition generictransformationdescriptors.hh:80
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation::recursive
    static const bool recursive
    Definition generictransformationdescriptors.hh:57
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation::transform
    static result< TC >::type transform(std::shared_ptr< const SourceNode > s, const Transformation &t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children)
    Definition generictransformationdescriptors.hh:74
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation::transform
    static result< TC >::type transform(const SourceNode &s, const Transformation &t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children)
    Definition generictransformationdescriptors.hh:68
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation::result
    Definition generictransformationdescriptors.hh:61
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation::result::type
    TransformedNodeTemplate< TC >::type type
    Definition generictransformationdescriptors.hh:62
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation::result::degree
    static const std::size_t degree
    Definition generictransformationdescriptors.hh:64
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation::result::storage_type
    std::shared_ptr< type > storage_type
    Definition generictransformationdescriptors.hh:63
    │ │ │ │ +
    Dune::TypeTree::GenericPowerNodeTransformation
    Definition generictransformationdescriptors.hh:96
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation
    Definition generictransformationdescriptors.hh:101
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation::transform
    static result< TC >::type transform(std::shared_ptr< const SourceNode > s, const Transformation &t, const std::vector< std::shared_ptr< TC > > &children)
    Definition generictransformationdescriptors.hh:119
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation::recursive
    static const bool recursive
    Definition generictransformationdescriptors.hh:103
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation::transform
    static result< TC >::type transform(const SourceNode &s, const Transformation &t, const std::vector< std::shared_ptr< TC > > &children)
    Definition generictransformationdescriptors.hh:113
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation::transform_storage
    static result< TC >::storage_type transform_storage(std::shared_ptr< const SourceNode > s, const Transformation &t, const std::vector< std::shared_ptr< TC > > &children)
    Definition generictransformationdescriptors.hh:125
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation::result
    Definition generictransformationdescriptors.hh:107
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation::result::type
    TransformedNodeTemplate< TC >::type type
    Definition generictransformationdescriptors.hh:108
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation::result::storage_type
    std::shared_ptr< type > storage_type
    Definition generictransformationdescriptors.hh:109
    │ │ │ │ +
    Dune::TypeTree::GenericDynamicPowerNodeTransformation
    Definition generictransformationdescriptors.hh:141
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation
    Definition generictransformationdescriptors.hh:146
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation::transform
    static result< TC... >::type transform(const SourceNode &s, const Transformation &t, std::shared_ptr< TC >... children)
    Definition generictransformationdescriptors.hh:158
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation::transform_storage
    static result< TC... >::storage_type transform_storage(std::shared_ptr< const SourceNode > s, const Transformation &t, std::shared_ptr< TC >... children)
    Definition generictransformationdescriptors.hh:170
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation::transform
    static result< TC... >::type transform(std::shared_ptr< const SourceNode > s, const Transformation &t, std::shared_ptr< TC >... children)
    Definition generictransformationdescriptors.hh:164
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation::recursive
    static const bool recursive
    Definition generictransformationdescriptors.hh:148
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation::result
    Definition generictransformationdescriptors.hh:152
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation::result::type
    TransformedNodeTemplate< TC... >::type type
    Definition generictransformationdescriptors.hh:153
    │ │ │ │ +
    Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation::result::storage_type
    std::shared_ptr< type > storage_type
    Definition generictransformationdescriptors.hh:154
    │ │ │ │ +
    Dune::TypeTree::GenericCompositeNodeTransformation
    Definition generictransformationdescriptors.hh:186
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,88 +1,347 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -leafnode.hh │ │ │ │ │ +generictransformationdescriptors.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_LEAFNODE_HH │ │ │ │ │ -7#define DUNE_TYPETREE_LEAFNODE_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_GENERICTRANSFORMATIONDESCRIPTORS_HH │ │ │ │ │ +7#define DUNE_TYPETREE_GENERICTRANSFORMATIONDESCRIPTORS_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ -10#include │ │ │ │ │ -11#include │ │ │ │ │ -12 │ │ │ │ │ -13namespace _D_u_n_e { │ │ │ │ │ -14 namespace TypeTree { │ │ │ │ │ -15 │ │ │ │ │ -_2_7 class _L_e_a_f_N_o_d_e │ │ │ │ │ +9#include │ │ │ │ │ +10#include │ │ │ │ │ +11 │ │ │ │ │ +12#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> │ │ │ │ │ +13#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ +14#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_p_o_w_e_r_c_o_m_p_o_s_i_t_e_n_o_d_e_t_r_a_n_s_f_o_r_m_a_t_i_o_n_t_e_m_p_l_a_t_e_s_._h_h> │ │ │ │ │ +15#include │ │ │ │ │ +16 │ │ │ │ │ +17 │ │ │ │ │ +18namespace _D_u_n_e { │ │ │ │ │ +19 namespace TypeTree { │ │ │ │ │ +20 │ │ │ │ │ +26 template │ │ │ │ │ +_2_7 struct _G_e_n_e_r_i_c_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ 28 { │ │ │ │ │ 29 │ │ │ │ │ -30 public: │ │ │ │ │ +_3_0 static const bool _r_e_c_u_r_s_i_v_e = false; │ │ │ │ │ 31 │ │ │ │ │ -_3_3 static const bool _i_s_L_e_a_f = true; │ │ │ │ │ +_3_2 typedef TransformedNode _t_r_a_n_s_f_o_r_m_e_d___t_y_p_e; │ │ │ │ │ +_3_3 typedef std::shared_ptr _t_r_a_n_s_f_o_r_m_e_d___s_t_o_r_a_g_e___t_y_p_e; │ │ │ │ │ 34 │ │ │ │ │ -_3_6 static const bool _i_s_P_o_w_e_r = false; │ │ │ │ │ -37 │ │ │ │ │ -_3_9 static const bool _i_s_C_o_m_p_o_s_i_t_e = false; │ │ │ │ │ -40 │ │ │ │ │ -_4_2 typedef _L_e_a_f_N_o_d_e_T_a_g _N_o_d_e_T_a_g; │ │ │ │ │ -43 │ │ │ │ │ -_4_4 static constexpr auto _d_e_g_r_e_e() │ │ │ │ │ -45 { │ │ │ │ │ -46 return std::integral_constant{}; │ │ │ │ │ -47 } │ │ │ │ │ -48 │ │ │ │ │ -49 protected: │ │ │ │ │ -50 │ │ │ │ │ +_3_5 static _t_r_a_n_s_f_o_r_m_e_d___t_y_p_e _t_r_a_n_s_f_o_r_m(const SourceNode& s, const Transformation& │ │ │ │ │ +t) │ │ │ │ │ +36 { │ │ │ │ │ +37 return _t_r_a_n_s_f_o_r_m_e_d___t_y_p_e(s,t); │ │ │ │ │ +38 } │ │ │ │ │ +39 │ │ │ │ │ +_4_0 static _t_r_a_n_s_f_o_r_m_e_d___t_y_p_e _t_r_a_n_s_f_o_r_m(std::shared_ptr s, const │ │ │ │ │ +Transformation& t) │ │ │ │ │ +41 { │ │ │ │ │ +42 return _t_r_a_n_s_f_o_r_m_e_d___t_y_p_e(s,t); │ │ │ │ │ +43 } │ │ │ │ │ +44 │ │ │ │ │ +_4_5 static _t_r_a_n_s_f_o_r_m_e_d___s_t_o_r_a_g_e___t_y_p_e _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std::shared_ptr s, const Transformation& t) │ │ │ │ │ +46 { │ │ │ │ │ +47 return std::make_shared(s,t); │ │ │ │ │ +48 } │ │ │ │ │ +49 │ │ │ │ │ +50 }; │ │ │ │ │ +51 │ │ │ │ │ 52 │ │ │ │ │ -_5_7 _L_e_a_f_N_o_d_e() {} │ │ │ │ │ -58 }; │ │ │ │ │ -59 │ │ │ │ │ -61 │ │ │ │ │ -62 } // namespace TypeTree │ │ │ │ │ -63} //namespace Dune │ │ │ │ │ -64 │ │ │ │ │ -65#endif // DUNE_TYPETREE_POWERNODE_HH │ │ │ │ │ +53 template class TransformedNodeTemplate> │ │ │ │ │ +_5_4 struct _T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +55 { │ │ │ │ │ +56 │ │ │ │ │ +_5_7 static const bool _r_e_c_u_r_s_i_v_e = true; │ │ │ │ │ +58 │ │ │ │ │ +59 template │ │ │ │ │ +_6_0 struct _r_e_s_u_l_t │ │ │ │ │ +61 { │ │ │ │ │ +_6_2 typedef typename TransformedNodeTemplate::type _t_y_p_e; │ │ │ │ │ +_6_3 typedef std::shared_ptr _s_t_o_r_a_g_e___t_y_p_e; │ │ │ │ │ +_6_4 static const std::size_t _d_e_g_r_e_e = _S_t_a_t_i_c_D_e_g_r_e_e_<_t_y_p_e_>_:_:_v_a_l_u_e; │ │ │ │ │ +65 }; │ │ │ │ │ +66 │ │ │ │ │ +67 template │ │ │ │ │ +_6_8 static typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e _t_r_a_n_s_f_o_r_m(const SourceNode& s, const │ │ │ │ │ +Transformation& t, const std::array,_r_e_s_u_l_t_<_T_C_>_:_:_d_e_g_r_e_e>& │ │ │ │ │ +children) │ │ │ │ │ +69 { │ │ │ │ │ +70 return typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e(s,t,children); │ │ │ │ │ +71 } │ │ │ │ │ +72 │ │ │ │ │ +73 template │ │ │ │ │ +_7_4 static typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e _t_r_a_n_s_f_o_r_m(std::shared_ptr │ │ │ │ │ +s, const Transformation& t, const std::array,_r_e_s_u_l_t_<_T_C_>_:_: │ │ │ │ │ +_d_e_g_r_e_e>& children) │ │ │ │ │ +75 { │ │ │ │ │ +76 return typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e(s,t,children); │ │ │ │ │ +77 } │ │ │ │ │ +78 │ │ │ │ │ +79 template │ │ │ │ │ +_8_0 static typename _r_e_s_u_l_t_<_T_C_>_:_:_s_t_o_r_a_g_e___t_y_p_e _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std:: │ │ │ │ │ +shared_ptr s, const Transformation& t, const std::array,_r_e_s_u_l_t_<_T_C_>_:_:_d_e_g_r_e_e>& children) │ │ │ │ │ +81 { │ │ │ │ │ +82 return std::make_shared::type>(s,t,children); │ │ │ │ │ +83 } │ │ │ │ │ +84 │ │ │ │ │ +85 }; │ │ │ │ │ +86 │ │ │ │ │ +87 │ │ │ │ │ +88 template class TransformedNode> │ │ │ │ │ +_8_9 struct _G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +90 : public _T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n::template result │ │ │ │ │ +95 > │ │ │ │ │ +96 {}; │ │ │ │ │ +97 │ │ │ │ │ +98 │ │ │ │ │ +99 template class TransformedNodeTemplate> │ │ │ │ │ +_1_0_0 struct _T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +101 { │ │ │ │ │ +102 │ │ │ │ │ +_1_0_3 static const bool _r_e_c_u_r_s_i_v_e = true; │ │ │ │ │ +104 │ │ │ │ │ +105 template │ │ │ │ │ +_1_0_6 struct _r_e_s_u_l_t │ │ │ │ │ +107 { │ │ │ │ │ +_1_0_8 typedef typename TransformedNodeTemplate::type _t_y_p_e; │ │ │ │ │ +_1_0_9 typedef std::shared_ptr _s_t_o_r_a_g_e___t_y_p_e; │ │ │ │ │ +110 }; │ │ │ │ │ +111 │ │ │ │ │ +112 template │ │ │ │ │ +_1_1_3 static typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e _t_r_a_n_s_f_o_r_m(const SourceNode& s, const │ │ │ │ │ +Transformation& t, const std::vector>& children) │ │ │ │ │ +114 { │ │ │ │ │ +115 return typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e(s,t,children); │ │ │ │ │ +116 } │ │ │ │ │ +117 │ │ │ │ │ +118 template │ │ │ │ │ +_1_1_9 static typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e _t_r_a_n_s_f_o_r_m(std::shared_ptr s, const Transformation& t, const std::vector>& │ │ │ │ │ +children) │ │ │ │ │ +120 { │ │ │ │ │ +121 return typename _r_e_s_u_l_t_<_T_C_>_:_:_t_y_p_e(s,t,children); │ │ │ │ │ +122 } │ │ │ │ │ +123 │ │ │ │ │ +124 template │ │ │ │ │ +_1_2_5 static typename _r_e_s_u_l_t_<_T_C_>_:_:_s_t_o_r_a_g_e___t_y_p_e _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std:: │ │ │ │ │ +shared_ptr s, const Transformation& t, const std:: │ │ │ │ │ +vector>& children) │ │ │ │ │ +126 { │ │ │ │ │ +127 return std::make_shared::type>(s,t,children); │ │ │ │ │ +128 } │ │ │ │ │ +129 │ │ │ │ │ +130 }; │ │ │ │ │ +131 │ │ │ │ │ +132 │ │ │ │ │ +133 template class TransformedNode> │ │ │ │ │ +_1_3_4 struct _G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +135 : public _T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n::template result │ │ │ │ │ +140 > │ │ │ │ │ +141 {}; │ │ │ │ │ +142 │ │ │ │ │ +143 │ │ │ │ │ +144 template class TransformedNodeTemplate> │ │ │ │ │ +_1_4_5 struct _T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +146 { │ │ │ │ │ +147 │ │ │ │ │ +_1_4_8 static const bool _r_e_c_u_r_s_i_v_e = true; │ │ │ │ │ +149 │ │ │ │ │ +150 template │ │ │ │ │ +_1_5_1 struct _r_e_s_u_l_t │ │ │ │ │ +152 { │ │ │ │ │ +_1_5_3 typedef typename TransformedNodeTemplate_:_:_t_y_p_e _t_y_p_e; │ │ │ │ │ +_1_5_4 typedef std::shared_ptr _s_t_o_r_a_g_e___t_y_p_e; │ │ │ │ │ +155 }; │ │ │ │ │ +156 │ │ │ │ │ +157 template │ │ │ │ │ +_1_5_8 static typename _r_e_s_u_l_t::type _t_r_a_n_s_f_o_r_m(const SourceNode& s, const │ │ │ │ │ +Transformation& t, std::shared_ptr... children) │ │ │ │ │ +159 { │ │ │ │ │ +160 return typename _r_e_s_u_l_t_<_T_C_._._._>_:_:_t_y_p_e(s,t,children...); │ │ │ │ │ +161 } │ │ │ │ │ +162 │ │ │ │ │ +163 template │ │ │ │ │ +_1_6_4 static typename _r_e_s_u_l_t::type _t_r_a_n_s_f_o_r_m(std::shared_ptr s, const Transformation& t, std::shared_ptr... children) │ │ │ │ │ +165 { │ │ │ │ │ +166 return typename _r_e_s_u_l_t_<_T_C_._._._>_:_:_t_y_p_e(s,t,children...); │ │ │ │ │ +167 } │ │ │ │ │ +168 │ │ │ │ │ +169 template │ │ │ │ │ +_1_7_0 static typename _r_e_s_u_l_t::storage_type _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std:: │ │ │ │ │ +shared_ptr s, const Transformation& t, std::shared_ptr... │ │ │ │ │ +children) │ │ │ │ │ +171 { │ │ │ │ │ +172 return std::make_shared::type>(s,t,children...); │ │ │ │ │ +173 } │ │ │ │ │ +174 │ │ │ │ │ +175 }; │ │ │ │ │ +176 │ │ │ │ │ +177 │ │ │ │ │ +178 template class TransformedNode> │ │ │ │ │ +_1_7_9 struct _G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +180 : public _T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n::template result │ │ │ │ │ +185 > │ │ │ │ │ +186 {}; │ │ │ │ │ +187 │ │ │ │ │ +189 │ │ │ │ │ +190 } // namespace TypeTree │ │ │ │ │ +191} //namespace Dune │ │ │ │ │ +192 │ │ │ │ │ +193#endif // DUNE_TYPETREE_GENERICTRANSFORMATIONDESCRIPTORS_HH │ │ │ │ │ _n_o_d_e_t_a_g_s_._h_h │ │ │ │ │ +_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h │ │ │ │ │ +_p_o_w_e_r_c_o_m_p_o_s_i_t_e_n_o_d_e_t_r_a_n_s_f_o_r_m_a_t_i_o_n_t_e_m_p_l_a_t_e_s_._h_h │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_D_e_g_r_e_e │ │ │ │ │ +decltype(Node::degree()) StaticDegree │ │ │ │ │ +Returns the statically known degree of the given Node type as a std:: │ │ │ │ │ +integral_constant. │ │ │ │ │ +DDeeffiinniittiioonn nodeinterface.hh:107 │ │ │ │ │ _D_u_n_e │ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e │ │ │ │ │ -Base class for leaf nodes in a dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn leafnode.hh:28 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e_:_:_N_o_d_e_T_a_g │ │ │ │ │ -LeafNodeTag NodeTag │ │ │ │ │ -The type tag that describes a LeafNode. │ │ │ │ │ -DDeeffiinniittiioonn leafnode.hh:42 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e_:_:_i_s_L_e_a_f │ │ │ │ │ -static const bool isLeaf │ │ │ │ │ -Mark this class as a leaf in a dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn leafnode.hh:33 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e_:_:_i_s_P_o_w_e_r │ │ │ │ │ -static const bool isPower │ │ │ │ │ -Mark this class as a non power in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn leafnode.hh:36 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e_:_:_L_e_a_f_N_o_d_e │ │ │ │ │ -LeafNode() │ │ │ │ │ -Default constructor. │ │ │ │ │ -DDeeffiinniittiioonn leafnode.hh:57 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e_:_:_i_s_C_o_m_p_o_s_i_t_e │ │ │ │ │ -static const bool isComposite │ │ │ │ │ -Mark this class as a non composite in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn leafnode.hh:39 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e_:_:_d_e_g_r_e_e │ │ │ │ │ -static constexpr auto degree() │ │ │ │ │ -DDeeffiinniittiioonn leafnode.hh:44 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e_T_a_g │ │ │ │ │ -Tag designating a leaf node. │ │ │ │ │ -DDeeffiinniittiioonn nodetags.hh:18 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:28 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m_e_d___t_y_p_e │ │ │ │ │ +TransformedNode transformed_type │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:32 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m_e_d___s_t_o_r_a_g_e___t_y_p_e │ │ │ │ │ +std::shared_ptr< transformed_type > transformed_storage_type │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:33 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ +static transformed_type transform(std::shared_ptr< const SourceNode > s, const │ │ │ │ │ +Transformation &t) │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:40 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_c_u_r_s_i_v_e │ │ │ │ │ +static const bool recursive │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:30 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ +static transformed_storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ +SourceNode > s, const Transformation &t) │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:45 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_L_e_a_f_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ +static transformed_type transform(const SourceNode &s, const Transformation &t) │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:35 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:55 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ +static result< TC >::storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ +SourceNode > s, const Transformation &t, const std::array< std::shared_ptr< TC │ │ │ │ │ +>, result< TC >::degree > &children) │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:80 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_c_u_r_s_i_v_e │ │ │ │ │ +static const bool recursive │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:57 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ +static result< TC >::type transform(std::shared_ptr< const SourceNode > s, │ │ │ │ │ +const Transformation &t, const std::array< std::shared_ptr< TC >, result< TC │ │ │ │ │ +>::degree > &children) │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:74 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ +static result< TC >::type transform(const SourceNode &s, const Transformation │ │ │ │ │ +&t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children) │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:68 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:61 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_t_y_p_e │ │ │ │ │ +TransformedNodeTemplate< TC >::type type │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:62 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_d_e_g_r_e_e │ │ │ │ │ +static const std::size_t degree │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:64 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_s_t_o_r_a_g_e___t_y_p_e │ │ │ │ │ +std::shared_ptr< type > storage_type │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:63 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:96 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:101 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ +static result< TC >::type transform(std::shared_ptr< const SourceNode > s, │ │ │ │ │ +const Transformation &t, const std::vector< std::shared_ptr< TC > > &children) │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:119 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_c_u_r_s_i_v_e │ │ │ │ │ +static const bool recursive │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:103 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ +static result< TC >::type transform(const SourceNode &s, const Transformation │ │ │ │ │ +&t, const std::vector< std::shared_ptr< TC > > &children) │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:113 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_: │ │ │ │ │ +_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ +static result< TC >::storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ +SourceNode > s, const Transformation &t, const std::vector< std::shared_ptr< TC │ │ │ │ │ +> > &children) │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:125 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:107 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_t_y_p_e │ │ │ │ │ +TransformedNodeTemplate< TC >::type type │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:108 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_: │ │ │ │ │ +_s_t_o_r_a_g_e___t_y_p_e │ │ │ │ │ +std::shared_ptr< type > storage_type │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:109 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:141 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:146 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ +static result< TC... >::type transform(const SourceNode &s, const │ │ │ │ │ +Transformation &t, std::shared_ptr< TC >... children) │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:158 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_: │ │ │ │ │ +_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ +static result< TC... >::storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ +SourceNode > s, const Transformation &t, std::shared_ptr< TC >... children) │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:170 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ +static result< TC... >::type transform(std::shared_ptr< const SourceNode > s, │ │ │ │ │ +const Transformation &t, std::shared_ptr< TC >... children) │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:164 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_c_u_r_s_i_v_e │ │ │ │ │ +static const bool recursive │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:148 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:152 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_:_t_y_p_e │ │ │ │ │ +TransformedNodeTemplate< TC... >::type type │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:153 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_e_m_p_l_a_t_i_z_e_d_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_:_:_r_e_s_u_l_t_:_: │ │ │ │ │ +_s_t_o_r_a_g_e___t_y_p_e │ │ │ │ │ +std::shared_ptr< type > storage_type │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:154 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +DDeeffiinniittiioonn generictransformationdescriptors.hh:186 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00071.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: filteredcompositenode.hh File Reference │ │ │ │ +dune-typetree: leafnode.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -72,35 +72,27 @@ │ │ │ │
  • dune
  • typetree
    • │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ Classes | │ │ │ │ Namespaces
    │ │ │ │ -
    filteredcompositenode.hh File Reference
    │ │ │ │ +
    leafnode.hh File Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │ -
    #include <memory>
    │ │ │ │ -#include <tuple>
    │ │ │ │ +
    #include <dune/typetree/nodetags.hh>
    │ │ │ │ +#include <cstddef>
    │ │ │ │ #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>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
    │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ 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::LeafNode
     Base class for leaf nodes in a dune-typetree. More...
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,31 +1,22 @@ │ │ │ │ │ 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 │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ +leafnode.hh File Reference │ │ │ │ │ #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_/_f_i_l_t_e_r_s_._h_h> │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ _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 │ │ │ │ │ - class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_<_ _N_o_d_e_,_ _F_i_l_t_e_r_ _> │ │ │ │ │ -  Base class for composite nodes representing a filtered view on an │ │ │ │ │ - underlying composite node. _M_o_r_e_._._. │ │ │ │ │ -  │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_<_ _N_o_d_e_,_ _F_i_l_t_e_r_ _>_:_:_C_h_i_l_d_<_ _k_ _> │ │ │ │ │ -  Access to the type and storage type of the i-th child. _M_o_r_e_._._. │ │ │ │ │ +class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e │ │ │ │ │ +  Base class for leaf nodes in a _d_u_n_e_-_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 │ │ │ │ │   │ │ │ │ │ =============================================================================== │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00071_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: filteredcompositenode.hh Source File │ │ │ │ +dune-typetree: leafnode.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,287 +74,75 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ -
    filteredcompositenode.hh
    │ │ │ │ +
    leafnode.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_LEAFNODE_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_LEAFNODE_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <memory>
    │ │ │ │ -
    10#include <tuple>
    │ │ │ │ +
    9#include <dune/typetree/nodetags.hh>
    │ │ │ │ +
    10#include <cstddef>
    │ │ │ │
    11#include <type_traits>
    │ │ │ │
    12
    │ │ │ │ -
    13#include <dune/typetree/nodetags.hh>
    │ │ │ │ -
    14#include <dune/typetree/filters.hh>
    │ │ │ │ -
    15#include <dune/common/shared_ptr.hh>
    │ │ │ │ -
    16#include <dune/common/typetraits.hh>
    │ │ │ │ -
    17#include <dune/common/indices.hh>
    │ │ │ │ -
    18
    │ │ │ │ -
    19#include <dune/typetree/filters.hh>
    │ │ │ │ -
    20#include <dune/typetree/nodetags.hh>
    │ │ │ │ -
    21
    │ │ │ │ -
    22namespace Dune {
    │ │ │ │ -
    23 namespace TypeTree {
    │ │ │ │ -
    24
    │ │ │ │ -
    30#ifndef DOXYGEN
    │ │ │ │ -
    31 namespace {
    │ │ │ │ -
    32
    │ │ │ │ -
    33 // ********************************************************************************
    │ │ │ │ -
    34 // Utility structs for filter construction and application
    │ │ │ │ -
    35 // ********************************************************************************
    │ │ │ │ -
    36
    │ │ │ │ -
    37 // Gets the filter and wraps it in case of a SimpleFilter.
    │ │ │ │ -
    38 template<typename Filter, typename Tag>
    │ │ │ │ -
    39 struct get_filter;
    │ │ │ │ +
    13namespace Dune {
    │ │ │ │ +
    14 namespace TypeTree {
    │ │ │ │ +
    15
    │ │ │ │ +
    │ │ │ │ +
    27 class LeafNode
    │ │ │ │ +
    28 {
    │ │ │ │ +
    29
    │ │ │ │ +
    30 public:
    │ │ │ │ +
    31
    │ │ │ │ +
    33 static const bool isLeaf = true;
    │ │ │ │ +
    34
    │ │ │ │ +
    36 static const bool isPower = false;
    │ │ │ │ +
    37
    │ │ │ │ +
    39 static const bool isComposite = false;
    │ │ │ │
    40
    │ │ │ │ -
    41 // Helper struct to extract the child template parameter pack from the ChildTypes tuple.
    │ │ │ │ -
    42 template<typename Filter, typename Node, typename ChildTypes>
    │ │ │ │ -
    43 struct apply_filter_wrapper;
    │ │ │ │ -
    44
    │ │ │ │ -
    45 template<typename Filter, typename Node, typename... Children>
    │ │ │ │ -
    46 struct apply_filter_wrapper<Filter,Node,std::tuple<Children...> >
    │ │ │ │ -
    47 : public Filter::template apply<Node,Children...>
    │ │ │ │ -
    48 {};
    │ │ │ │ -
    49
    │ │ │ │ -
    50 // specialization for SimpleFilter
    │ │ │ │ -
    51 template<typename Filter>
    │ │ │ │ -
    52 struct get_filter<Filter,SimpleFilterTag>
    │ │ │ │ -
    53 {
    │ │ │ │ -
    54 struct type
    │ │ │ │ -
    55 {
    │ │ │ │ -
    56 template<typename Node, typename ChildTypes>
    │ │ │ │ -
    57 struct apply
    │ │ │ │ -
    58 : public apply_filter_wrapper<filter<Filter>,Node,ChildTypes>
    │ │ │ │ -
    59 {};
    │ │ │ │ -
    60 };
    │ │ │ │ -
    61 };
    │ │ │ │ -
    62
    │ │ │ │ -
    63 // specialization for AdvancedFilter
    │ │ │ │ -
    64 template<typename Filter>
    │ │ │ │ -
    65 struct get_filter<Filter,AdvancedFilterTag>
    │ │ │ │ -
    66 {
    │ │ │ │ -
    67 struct type
    │ │ │ │ -
    68 {
    │ │ │ │ -
    69 template<typename Node, typename ChildTypes>
    │ │ │ │ -
    70 struct apply
    │ │ │ │ -
    71 : public apply_filter_wrapper<Filter,Node,ChildTypes>
    │ │ │ │ -
    72 {};
    │ │ │ │ -
    73 };
    │ │ │ │ -
    74 };
    │ │ │ │ -
    75
    │ │ │ │ -
    76 } // anonymous namespace
    │ │ │ │ -
    77#endif // DOXYGEN
    │ │ │ │ -
    78
    │ │ │ │ -
    79
    │ │ │ │ -
    81 template<typename Node, typename Filter>
    │ │ │ │ -
    │ │ │ │ -
    82 class FilteredCompositeNode
    │ │ │ │ -
    83 {
    │ │ │ │ -
    84
    │ │ │ │ -
    85 typedef typename get_filter<Filter,typename Filter::FilterTag>::type filter;
    │ │ │ │ -
    86 typedef typename filter::template apply<Node,typename Node::ChildTypes>::type filter_result;
    │ │ │ │ -
    87 typedef typename filter_result::template apply<Node> mapped_children;
    │ │ │ │ -
    88
    │ │ │ │ -
    89 static const bool nodeIsConst = std::is_const<typename std::remove_reference<Node>::type>::value;
    │ │ │ │ -
    90
    │ │ │ │ -
    91 template<std::size_t k>
    │ │ │ │ -
    92 struct lazy_enable
    │ │ │ │ -
    93 {
    │ │ │ │ -
    94 static const bool value = !nodeIsConst;
    │ │ │ │ -
    95 };
    │ │ │ │ -
    96
    │ │ │ │ -
    97 public:
    │ │ │ │ -
    98
    │ │ │ │ -
    100 typedef CompositeNodeTag NodeTag;
    │ │ │ │ -
    101
    │ │ │ │ -
    103 typedef typename mapped_children::NodeStorage NodeStorage;
    │ │ │ │ -
    104
    │ │ │ │ -
    106 typedef typename mapped_children::ChildTypes ChildTypes;
    │ │ │ │ -
    107
    │ │ │ │ -
    109 static const bool isLeaf = false;
    │ │ │ │ -
    110
    │ │ │ │ -
    112 static const bool isPower = false;
    │ │ │ │ -
    113
    │ │ │ │ -
    115 static const bool isComposite = true;
    │ │ │ │ -
    116
    │ │ │ │ -
    │ │ │ │ -
    117 static constexpr auto degree ()
    │ │ │ │ -
    118 {
    │ │ │ │ -
    119 return std::integral_constant<std::size_t,filter_result::size>{};
    │ │ │ │ -
    120 }
    │ │ │ │ -
    │ │ │ │ -
    121
    │ │ │ │ -
    123 template<std::size_t k>
    │ │ │ │ -
    │ │ │ │ -
    124 struct Child {
    │ │ │ │ -
    125
    │ │ │ │ -
    126#ifndef DOXYGEN
    │ │ │ │ -
    127
    │ │ │ │ -
    128 typedef typename std::tuple_element<k,typename mapped_children::Children>::type OriginalChild;
    │ │ │ │ -
    129
    │ │ │ │ -
    130 static const std::size_t mapped_index = std::tuple_element<k,typename filter_result::IndexMap>::type::original_index;
    │ │ │ │ -
    131
    │ │ │ │ -
    132#endif // DOXYGEN
    │ │ │ │ -
    133
    │ │ │ │ -
    135 typedef typename OriginalChild::Type Type;
    │ │ │ │ -
    136
    │ │ │ │ -
    138 typedef typename OriginalChild::type type;
    │ │ │ │ -
    139 };
    │ │ │ │ -
    │ │ │ │ -
    140
    │ │ │ │ -
    143
    │ │ │ │ -
    145
    │ │ │ │ -
    148 template<std::size_t k,
    │ │ │ │ -
    149 typename std::enable_if<lazy_enable<k>::value, int>::type = 0>
    │ │ │ │ -
    │ │ │ │ -
    150 auto& child (index_constant<k> = {})
    │ │ │ │ -
    151 {
    │ │ │ │ -
    152 return _node->template child<Child<k>::mapped_index>();
    │ │ │ │ -
    153 }
    │ │ │ │ -
    │ │ │ │ -
    154
    │ │ │ │ -
    156
    │ │ │ │ -
    159 template<std::size_t k>
    │ │ │ │ -
    │ │ │ │ -
    160 const auto& child (index_constant<k> = {}) const
    │ │ │ │ -
    161 {
    │ │ │ │ -
    162 return _node->template child<Child<k>::mapped_index>();
    │ │ │ │ -
    163 }
    │ │ │ │ -
    │ │ │ │ -
    164
    │ │ │ │ -
    166
    │ │ │ │ -
    169 template<std::size_t k,
    │ │ │ │ -
    170 typename std::enable_if<lazy_enable<k>::value, int>::type = 0>
    │ │ │ │ -
    │ │ │ │ -
    171 auto childStorage (index_constant<k> = {})
    │ │ │ │ -
    172 {
    │ │ │ │ -
    173 return _node->template childStorage<Child<k>::mapped_index>();
    │ │ │ │ -
    174 }
    │ │ │ │ -
    │ │ │ │ -
    175
    │ │ │ │ -
    177
    │ │ │ │ -
    180 template<std::size_t k>
    │ │ │ │ -
    │ │ │ │ -
    181 auto childStorage (index_constant<k> = {}) const
    │ │ │ │ -
    182 {
    │ │ │ │ -
    183 return _node->template childStorage<Child<k>::mapped_index>();
    │ │ │ │ -
    184 }
    │ │ │ │ -
    │ │ │ │ -
    185
    │ │ │ │ -
    187 template<std::size_t k, class ChildType>
    │ │ │ │ -
    │ │ │ │ -
    188 void setChild (ChildType&& child, typename std::enable_if<lazy_enable<k>::value,void*>::type = 0)
    │ │ │ │ -
    189 {
    │ │ │ │ -
    190 _node->template setChild<Child<k>::mapped_index>(std::forward<ChildType>(child));
    │ │ │ │ -
    191 }
    │ │ │ │ -
    │ │ │ │ -
    192
    │ │ │ │ -
    194
    │ │ │ │ -
    197
    │ │ │ │ -
    198 protected:
    │ │ │ │ -
    199
    │ │ │ │ -
    201
    │ │ │ │ -
    204 template<bool enabled = !nodeIsConst>
    │ │ │ │ -
    205 typename std::enable_if<enabled,Node&>::type
    │ │ │ │ -
    │ │ │ │ -
    206 unfiltered ()
    │ │ │ │ -
    207 {
    │ │ │ │ -
    208 return *_node;
    │ │ │ │ -
    209 }
    │ │ │ │ -
    │ │ │ │ -
    210
    │ │ │ │ -
    212
    │ │ │ │ -
    │ │ │ │ -
    215 const Node& unfiltered () const
    │ │ │ │ -
    216 {
    │ │ │ │ -
    217 return *_node;
    │ │ │ │ -
    218 }
    │ │ │ │ -
    │ │ │ │ -
    219
    │ │ │ │ -
    221
    │ │ │ │ -
    224 template<bool enabled = !nodeIsConst>
    │ │ │ │ -
    225 typename std::enable_if<enabled,std::shared_ptr<Node> >::type
    │ │ │ │ -
    │ │ │ │ -
    226 unfilteredStorage ()
    │ │ │ │ -
    227 {
    │ │ │ │ -
    228 return _node;
    │ │ │ │ -
    229 }
    │ │ │ │ -
    │ │ │ │ -
    230
    │ │ │ │ -
    232
    │ │ │ │ -
    │ │ │ │ -
    235 std::shared_ptr<const Node> unfilteredStorage () const
    │ │ │ │ -
    236 {
    │ │ │ │ -
    237 return _node;
    │ │ │ │ -
    238 }
    │ │ │ │ -
    │ │ │ │ -
    239
    │ │ │ │ -
    241
    │ │ │ │ -
    242 public:
    │ │ │ │ -
    243
    │ │ │ │ -
    246
    │ │ │ │ -
    │ │ │ │ -
    248 FilteredCompositeNode (std::shared_ptr<Node> node)
    │ │ │ │ -
    249 : _node(std::move(node))
    │ │ │ │ -
    250 {}
    │ │ │ │ -
    │ │ │ │ -
    251
    │ │ │ │ -
    │ │ │ │ -
    253 FilteredCompositeNode (Node& node)
    │ │ │ │ -
    254 : _node(stackobject_to_shared_ptr(node))
    │ │ │ │ -
    255 {}
    │ │ │ │ -
    │ │ │ │ -
    256
    │ │ │ │ -
    258
    │ │ │ │ -
    259 private:
    │ │ │ │ -
    260 std::shared_ptr<Node> _node;
    │ │ │ │ -
    261 };
    │ │ │ │ -
    │ │ │ │ -
    262
    │ │ │ │ -
    264
    │ │ │ │ -
    265 } // namespace TypeTree
    │ │ │ │ -
    266} //namespace Dune
    │ │ │ │ -
    267
    │ │ │ │ -
    268#endif // DUNE_TYPETREE_FILTEREDCOMPOSITENODE_HH
    │ │ │ │ - │ │ │ │ - │ │ │ │ +
    42 typedef LeafNodeTag NodeTag;
    │ │ │ │ +
    43
    │ │ │ │ +
    │ │ │ │ +
    44 static constexpr auto degree()
    │ │ │ │ +
    45 {
    │ │ │ │ +
    46 return std::integral_constant<std::size_t,0>{};
    │ │ │ │ +
    47 }
    │ │ │ │ +
    │ │ │ │ +
    48
    │ │ │ │ +
    49 protected:
    │ │ │ │ +
    50
    │ │ │ │ +
    52
    │ │ │ │ +
    57 LeafNode() {}
    │ │ │ │ +
    58 };
    │ │ │ │ +
    │ │ │ │ +
    59
    │ │ │ │ +
    61
    │ │ │ │ +
    62 } // namespace TypeTree
    │ │ │ │ +
    63} //namespace Dune
    │ │ │ │ +
    64
    │ │ │ │ +
    65#endif // DUNE_TYPETREE_POWERNODE_HH
    │ │ │ │ + │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode
    Base class for composite nodes representing a filtered view on an underlying composite node.
    Definition filteredcompositenode.hh:83
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::childStorage
    auto childStorage(index_constant< k >={}) const
    Returns the storage of the k-th child (const version).
    Definition filteredcompositenode.hh:181
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::degree
    static constexpr auto degree()
    Definition filteredcompositenode.hh:117
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::NodeStorage
    mapped_children::NodeStorage NodeStorage
    The type used for storing the children.
    Definition filteredcompositenode.hh:103
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::setChild
    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
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::isLeaf
    static const bool isLeaf
    Mark this class as non leaf in the dune-typetree.
    Definition filteredcompositenode.hh:109
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::unfiltered
    const Node & unfiltered() const
    Returns the unfiltered node (const version).
    Definition filteredcompositenode.hh:215
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::isComposite
    static const bool isComposite
    Mark this class as a composite in the dune-typetree.
    Definition filteredcompositenode.hh:115
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::unfilteredStorage
    std::enable_if< enabled, std::shared_ptr< Node > >::type unfilteredStorage()
    Returns the storage object of the unfiltered node.
    Definition filteredcompositenode.hh:226
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::isPower
    static const bool isPower
    Mark this class as a non power in the dune-typetree.
    Definition filteredcompositenode.hh:112
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::FilteredCompositeNode
    FilteredCompositeNode(Node &node)
    Initialize the CompositeNode with a copy of the passed-in storage type.
    Definition filteredcompositenode.hh:253
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::FilteredCompositeNode
    FilteredCompositeNode(std::shared_ptr< Node > node)
    Initialize the CompositeNode with copies of the passed in Storage objects.
    Definition filteredcompositenode.hh:248
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::childStorage
    auto childStorage(index_constant< k >={})
    Returns the storage of the k-th child.
    Definition filteredcompositenode.hh:171
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::child
    const auto & child(index_constant< k >={}) const
    Returns the k-th child (const version).
    Definition filteredcompositenode.hh:160
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::child
    auto & child(index_constant< k >={})
    Returns the k-th child.
    Definition filteredcompositenode.hh:150
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::NodeTag
    CompositeNodeTag NodeTag
    The type tag that describes a CompositeNode.
    Definition filteredcompositenode.hh:100
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::ChildTypes
    mapped_children::ChildTypes ChildTypes
    A tuple storing the types of all children.
    Definition filteredcompositenode.hh:106
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::unfiltered
    std::enable_if< enabled, Node & >::type unfiltered()
    Returns the unfiltered node.
    Definition filteredcompositenode.hh:206
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::unfilteredStorage
    std::shared_ptr< const Node > unfilteredStorage() const
    Returns the storage object of the unfiltered node (const version).
    Definition filteredcompositenode.hh:235
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::Child
    Access to the type and storage type of the i-th child.
    Definition filteredcompositenode.hh:124
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::Child::type
    OriginalChild::type type
    The type of the child.
    Definition filteredcompositenode.hh:138
    │ │ │ │ -
    Dune::TypeTree::FilteredCompositeNode::Child::Type
    OriginalChild::Type Type
    The type of the child.
    Definition filteredcompositenode.hh:135
    │ │ │ │ -
    Dune::TypeTree::CompositeNodeTag
    Tag designating a composite node.
    Definition nodetags.hh:27
    │ │ │ │ +
    Dune::TypeTree::LeafNode
    Base class for leaf nodes in a dune-typetree.
    Definition leafnode.hh:28
    │ │ │ │ +
    Dune::TypeTree::LeafNode::NodeTag
    LeafNodeTag NodeTag
    The type tag that describes a LeafNode.
    Definition leafnode.hh:42
    │ │ │ │ +
    Dune::TypeTree::LeafNode::isLeaf
    static const bool isLeaf
    Mark this class as a leaf in a dune-typetree.
    Definition leafnode.hh:33
    │ │ │ │ +
    Dune::TypeTree::LeafNode::isPower
    static const bool isPower
    Mark this class as a non power in the dune-typetree.
    Definition leafnode.hh:36
    │ │ │ │ +
    Dune::TypeTree::LeafNode::LeafNode
    LeafNode()
    Default constructor.
    Definition leafnode.hh:57
    │ │ │ │ +
    Dune::TypeTree::LeafNode::isComposite
    static const bool isComposite
    Mark this class as a non composite in the dune-typetree.
    Definition leafnode.hh:39
    │ │ │ │ +
    Dune::TypeTree::LeafNode::degree
    static constexpr auto degree()
    Definition leafnode.hh:44
    │ │ │ │ +
    Dune::TypeTree::LeafNodeTag
    Tag designating a leaf node.
    Definition nodetags.hh:18
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,333 +1,88 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -filteredcompositenode.hh │ │ │ │ │ +leafnode.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 │ │ │ │ │ +6#ifndef DUNE_TYPETREE_LEAFNODE_HH │ │ │ │ │ +7#define DUNE_TYPETREE_LEAFNODE_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include │ │ │ │ │ -10#include │ │ │ │ │ +9#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ +10#include │ │ │ │ │ 11#include │ │ │ │ │ 12 │ │ │ │ │ -13#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ -14#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_f_i_l_t_e_r_s_._h_h> │ │ │ │ │ -15#include │ │ │ │ │ -16#include │ │ │ │ │ -17#include │ │ │ │ │ -18 │ │ │ │ │ -19#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_f_i_l_t_e_r_s_._h_h> │ │ │ │ │ -20#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ -21 │ │ │ │ │ -22namespace _D_u_n_e { │ │ │ │ │ -23 namespace TypeTree { │ │ │ │ │ -24 │ │ │ │ │ -30#ifndef DOXYGEN │ │ │ │ │ -31 namespace { │ │ │ │ │ -32 │ │ │ │ │ -33 / │ │ │ │ │ -/ │ │ │ │ │ -******************************************************************************** │ │ │ │ │ -34 // Utility structs for filter construction and application │ │ │ │ │ -35 / │ │ │ │ │ -/ │ │ │ │ │ -******************************************************************************** │ │ │ │ │ -36 │ │ │ │ │ -37 // Gets the filter and wraps it in case of a SimpleFilter. │ │ │ │ │ -38 template │ │ │ │ │ -39 struct get_filter; │ │ │ │ │ +13namespace _D_u_n_e { │ │ │ │ │ +14 namespace TypeTree { │ │ │ │ │ +15 │ │ │ │ │ +_2_7 class _L_e_a_f_N_o_d_e │ │ │ │ │ +28 { │ │ │ │ │ +29 │ │ │ │ │ +30 public: │ │ │ │ │ +31 │ │ │ │ │ +_3_3 static const bool _i_s_L_e_a_f = true; │ │ │ │ │ +34 │ │ │ │ │ +_3_6 static const bool _i_s_P_o_w_e_r = false; │ │ │ │ │ +37 │ │ │ │ │ +_3_9 static const bool _i_s_C_o_m_p_o_s_i_t_e = false; │ │ │ │ │ 40 │ │ │ │ │ -41 // Helper struct to extract the child template parameter pack from the │ │ │ │ │ -ChildTypes tuple. │ │ │ │ │ -42 template │ │ │ │ │ -43 struct apply_filter_wrapper; │ │ │ │ │ -44 │ │ │ │ │ -45 template │ │ │ │ │ -46 struct apply_filter_wrapper > │ │ │ │ │ -47 : public Filter::template apply │ │ │ │ │ -48 {}; │ │ │ │ │ -49 │ │ │ │ │ -50 // specialization for SimpleFilter │ │ │ │ │ -51 template │ │ │ │ │ -52 struct get_filter │ │ │ │ │ -53 { │ │ │ │ │ -54 struct type │ │ │ │ │ -55 { │ │ │ │ │ -56 template │ │ │ │ │ -57 struct apply │ │ │ │ │ -58 : public apply_filter_wrapper,Node,ChildTypes> │ │ │ │ │ -59 {}; │ │ │ │ │ -60 }; │ │ │ │ │ -61 }; │ │ │ │ │ -62 │ │ │ │ │ -63 // specialization for AdvancedFilter │ │ │ │ │ -64 template │ │ │ │ │ -65 struct get_filter │ │ │ │ │ -66 { │ │ │ │ │ -67 struct type │ │ │ │ │ -68 { │ │ │ │ │ -69 template │ │ │ │ │ -70 struct apply │ │ │ │ │ -71 : public apply_filter_wrapper │ │ │ │ │ -72 {}; │ │ │ │ │ -73 }; │ │ │ │ │ -74 }; │ │ │ │ │ -75 │ │ │ │ │ -76 } // anonymous namespace │ │ │ │ │ -77#endif // DOXYGEN │ │ │ │ │ -78 │ │ │ │ │ -79 │ │ │ │ │ -81 template │ │ │ │ │ -_8_2 class _F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e │ │ │ │ │ -83 { │ │ │ │ │ -84 │ │ │ │ │ -85 typedef typename get_filter::type filter; │ │ │ │ │ -86 typedef typename filter::template apply:: │ │ │ │ │ -type filter_result; │ │ │ │ │ -87 typedef typename filter_result::template apply mapped_children; │ │ │ │ │ -88 │ │ │ │ │ -89 static const bool nodeIsConst = std::is_const::type>::value; │ │ │ │ │ -90 │ │ │ │ │ -91 template │ │ │ │ │ -92 struct lazy_enable │ │ │ │ │ -93 { │ │ │ │ │ -94 static const bool value = !nodeIsConst; │ │ │ │ │ -95 }; │ │ │ │ │ -96 │ │ │ │ │ -97 public: │ │ │ │ │ -98 │ │ │ │ │ -_1_0_0 typedef _C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g _N_o_d_e_T_a_g; │ │ │ │ │ -101 │ │ │ │ │ -_1_0_3 typedef typename mapped_children::NodeStorage _N_o_d_e_S_t_o_r_a_g_e; │ │ │ │ │ -104 │ │ │ │ │ -_1_0_6 typedef typename mapped_children::ChildTypes _C_h_i_l_d_T_y_p_e_s; │ │ │ │ │ -107 │ │ │ │ │ -_1_0_9 static const bool _i_s_L_e_a_f = false; │ │ │ │ │ -110 │ │ │ │ │ -_1_1_2 static const bool _i_s_P_o_w_e_r = false; │ │ │ │ │ -113 │ │ │ │ │ -_1_1_5 static const bool _i_s_C_o_m_p_o_s_i_t_e = true; │ │ │ │ │ -116 │ │ │ │ │ -_1_1_7 static constexpr auto _d_e_g_r_e_e () │ │ │ │ │ -118 { │ │ │ │ │ -119 return std::integral_constant{}; │ │ │ │ │ -120 } │ │ │ │ │ -121 │ │ │ │ │ -123 template │ │ │ │ │ -_1_2_4 struct _C_h_i_l_d { │ │ │ │ │ -125 │ │ │ │ │ -126#ifndef DOXYGEN │ │ │ │ │ -127 │ │ │ │ │ -128 typedef typename std::tuple_element:: │ │ │ │ │ -type OriginalChild; │ │ │ │ │ -129 │ │ │ │ │ -130 static const std::size_t mapped_index = std::tuple_element::type::original_index; │ │ │ │ │ -131 │ │ │ │ │ -132#endif // DOXYGEN │ │ │ │ │ -133 │ │ │ │ │ -_1_3_5 typedef typename OriginalChild::Type _T_y_p_e; │ │ │ │ │ -136 │ │ │ │ │ -_1_3_8 typedef typename OriginalChild::type _t_y_p_e; │ │ │ │ │ -139 }; │ │ │ │ │ -140 │ │ │ │ │ -143 │ │ │ │ │ -145 │ │ │ │ │ -148 template::value, int>::type = 0> │ │ │ │ │ -_1_5_0 auto& _c_h_i_l_d (index_constant = {}) │ │ │ │ │ -151 { │ │ │ │ │ -152 return _node->template child::mapped_index>(); │ │ │ │ │ -153 } │ │ │ │ │ -154 │ │ │ │ │ -156 │ │ │ │ │ -159 template │ │ │ │ │ -_1_6_0 const auto& _c_h_i_l_d (index_constant = {}) const │ │ │ │ │ -161 { │ │ │ │ │ -162 return _node->template child::mapped_index>(); │ │ │ │ │ -163 } │ │ │ │ │ -164 │ │ │ │ │ -166 │ │ │ │ │ -169 template::value, int>::type = 0> │ │ │ │ │ -_1_7_1 auto _c_h_i_l_d_S_t_o_r_a_g_e (index_constant = {}) │ │ │ │ │ -172 { │ │ │ │ │ -173 return _node->template childStorage::mapped_index>(); │ │ │ │ │ -174 } │ │ │ │ │ -175 │ │ │ │ │ -177 │ │ │ │ │ -180 template │ │ │ │ │ -_1_8_1 auto _c_h_i_l_d_S_t_o_r_a_g_e (index_constant = {}) const │ │ │ │ │ -182 { │ │ │ │ │ -183 return _node->template childStorage::mapped_index>(); │ │ │ │ │ -184 } │ │ │ │ │ -185 │ │ │ │ │ -187 template │ │ │ │ │ -_1_8_8 void _s_e_t_C_h_i_l_d (ChildType&& _c_h_i_l_d, typename std::enable_if:: │ │ │ │ │ -value,void*>::type = 0) │ │ │ │ │ -189 { │ │ │ │ │ -190 _node->template setChild::mapped_index>(std::forward │ │ │ │ │ -(_c_h_i_l_d)); │ │ │ │ │ -191 } │ │ │ │ │ -192 │ │ │ │ │ -194 │ │ │ │ │ -197 │ │ │ │ │ -198 protected: │ │ │ │ │ -199 │ │ │ │ │ -201 │ │ │ │ │ -204 template │ │ │ │ │ -205 typename std::enable_if::type │ │ │ │ │ -_2_0_6 _u_n_f_i_l_t_e_r_e_d () │ │ │ │ │ -207 { │ │ │ │ │ -208 return *_node; │ │ │ │ │ -209 } │ │ │ │ │ -210 │ │ │ │ │ -212 │ │ │ │ │ -_2_1_5 const Node& _u_n_f_i_l_t_e_r_e_d () const │ │ │ │ │ -216 { │ │ │ │ │ -217 return *_node; │ │ │ │ │ -218 } │ │ │ │ │ -219 │ │ │ │ │ -221 │ │ │ │ │ -224 template │ │ │ │ │ -225 typename std::enable_if >::type │ │ │ │ │ -_2_2_6 _u_n_f_i_l_t_e_r_e_d_S_t_o_r_a_g_e () │ │ │ │ │ -227 { │ │ │ │ │ -228 return _node; │ │ │ │ │ -229 } │ │ │ │ │ -230 │ │ │ │ │ -232 │ │ │ │ │ -_2_3_5 std::shared_ptr _u_n_f_i_l_t_e_r_e_d_S_t_o_r_a_g_e () const │ │ │ │ │ -236 { │ │ │ │ │ -237 return _node; │ │ │ │ │ -238 } │ │ │ │ │ -239 │ │ │ │ │ -241 │ │ │ │ │ -242 public: │ │ │ │ │ -243 │ │ │ │ │ -246 │ │ │ │ │ -_2_4_8 _F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e (std::shared_ptr node) │ │ │ │ │ -249 : _node(std::move(node)) │ │ │ │ │ -250 {} │ │ │ │ │ -251 │ │ │ │ │ -_2_5_3 _F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e (Node& node) │ │ │ │ │ -254 : _node(stackobject_to_shared_ptr(node)) │ │ │ │ │ -255 {} │ │ │ │ │ -256 │ │ │ │ │ -258 │ │ │ │ │ -259 private: │ │ │ │ │ -260 std::shared_ptr _node; │ │ │ │ │ -261 }; │ │ │ │ │ -262 │ │ │ │ │ -264 │ │ │ │ │ -265 } // namespace TypeTree │ │ │ │ │ -266} //namespace Dune │ │ │ │ │ -267 │ │ │ │ │ -268#endif // DUNE_TYPETREE_FILTEREDCOMPOSITENODE_HH │ │ │ │ │ +_4_2 typedef _L_e_a_f_N_o_d_e_T_a_g _N_o_d_e_T_a_g; │ │ │ │ │ +43 │ │ │ │ │ +_4_4 static constexpr auto _d_e_g_r_e_e() │ │ │ │ │ +45 { │ │ │ │ │ +46 return std::integral_constant{}; │ │ │ │ │ +47 } │ │ │ │ │ +48 │ │ │ │ │ +49 protected: │ │ │ │ │ +50 │ │ │ │ │ +52 │ │ │ │ │ +_5_7 _L_e_a_f_N_o_d_e() {} │ │ │ │ │ +58 }; │ │ │ │ │ +59 │ │ │ │ │ +61 │ │ │ │ │ +62 } // namespace TypeTree │ │ │ │ │ +63} //namespace Dune │ │ │ │ │ +64 │ │ │ │ │ +65#endif // DUNE_TYPETREE_POWERNODE_HH │ │ │ │ │ _n_o_d_e_t_a_g_s_._h_h │ │ │ │ │ -_f_i_l_t_e_r_s_._h_h │ │ │ │ │ _D_u_n_e │ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e │ │ │ │ │ -Base class for composite nodes representing a filtered view on an underlying │ │ │ │ │ -composite node. │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:83 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ -auto childStorage(index_constant< k >={}) const │ │ │ │ │ -Returns the storage of the k-th child (const version). │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:181 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_d_e_g_r_e_e │ │ │ │ │ -static constexpr auto degree() │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:117 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ -mapped_children::NodeStorage NodeStorage │ │ │ │ │ -The type used for storing the children. │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:103 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ -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. │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:188 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_i_s_L_e_a_f │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e │ │ │ │ │ +Base class for leaf nodes in a dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn leafnode.hh:28 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e_:_:_N_o_d_e_T_a_g │ │ │ │ │ +LeafNodeTag NodeTag │ │ │ │ │ +The type tag that describes a LeafNode. │ │ │ │ │ +DDeeffiinniittiioonn leafnode.hh:42 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e_:_:_i_s_L_e_a_f │ │ │ │ │ static const bool isLeaf │ │ │ │ │ -Mark this class as non leaf in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:109 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_u_n_f_i_l_t_e_r_e_d │ │ │ │ │ -const Node & unfiltered() const │ │ │ │ │ -Returns the unfiltered node (const version). │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:215 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_i_s_C_o_m_p_o_s_i_t_e │ │ │ │ │ -static const bool isComposite │ │ │ │ │ -Mark this class as a composite in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:115 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_u_n_f_i_l_t_e_r_e_d_S_t_o_r_a_g_e │ │ │ │ │ -std::enable_if< enabled, std::shared_ptr< Node > >::type unfilteredStorage() │ │ │ │ │ -Returns the storage object of the unfiltered node. │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:226 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_i_s_P_o_w_e_r │ │ │ │ │ +Mark this class as a leaf in a dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn leafnode.hh:33 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e_:_:_i_s_P_o_w_e_r │ │ │ │ │ static const bool isPower │ │ │ │ │ Mark this class as a non power in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:112 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e │ │ │ │ │ -FilteredCompositeNode(Node &node) │ │ │ │ │ -Initialize the CompositeNode with a copy of the passed-in storage type. │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:253 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e │ │ │ │ │ -FilteredCompositeNode(std::shared_ptr< Node > node) │ │ │ │ │ -Initialize the CompositeNode with copies of the passed in Storage objects. │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:248 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ -auto childStorage(index_constant< k >={}) │ │ │ │ │ -Returns the storage of the k-th child. │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:171 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ -const auto & child(index_constant< k >={}) const │ │ │ │ │ -Returns the k-th child (const version). │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:160 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ -auto & child(index_constant< k >={}) │ │ │ │ │ -Returns the k-th child. │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:150 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_N_o_d_e_T_a_g │ │ │ │ │ -CompositeNodeTag NodeTag │ │ │ │ │ -The type tag that describes a CompositeNode. │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:100 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_h_i_l_d_T_y_p_e_s │ │ │ │ │ -mapped_children::ChildTypes ChildTypes │ │ │ │ │ -A tuple storing the types of all children. │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:106 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_u_n_f_i_l_t_e_r_e_d │ │ │ │ │ -std::enable_if< enabled, Node & >::type unfiltered() │ │ │ │ │ -Returns the unfiltered node. │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:206 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_u_n_f_i_l_t_e_r_e_d_S_t_o_r_a_g_e │ │ │ │ │ -std::shared_ptr< const Node > unfilteredStorage() const │ │ │ │ │ -Returns the storage object of the unfiltered node (const version). │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:235 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_h_i_l_d │ │ │ │ │ -Access to the type and storage type of the i-th child. │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:124 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_h_i_l_d_:_:_t_y_p_e │ │ │ │ │ -OriginalChild::type type │ │ │ │ │ -The type of the child. │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:138 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_h_i_l_d_:_:_T_y_p_e │ │ │ │ │ -OriginalChild::Type Type │ │ │ │ │ -The type of the child. │ │ │ │ │ -DDeeffiinniittiioonn filteredcompositenode.hh:135 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g │ │ │ │ │ -Tag designating a composite node. │ │ │ │ │ -DDeeffiinniittiioonn nodetags.hh:27 │ │ │ │ │ +DDeeffiinniittiioonn leafnode.hh:36 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e_:_:_L_e_a_f_N_o_d_e │ │ │ │ │ +LeafNode() │ │ │ │ │ +Default constructor. │ │ │ │ │ +DDeeffiinniittiioonn leafnode.hh:57 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e_:_:_i_s_C_o_m_p_o_s_i_t_e │ │ │ │ │ +static const bool isComposite │ │ │ │ │ +Mark this class as a non composite in the dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn leafnode.hh:39 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e_:_:_d_e_g_r_e_e │ │ │ │ │ +static constexpr auto degree() │ │ │ │ │ +DDeeffiinniittiioonn leafnode.hh:44 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e_T_a_g │ │ │ │ │ +Tag designating a leaf node. │ │ │ │ │ +DDeeffiinniittiioonn nodetags.hh:18 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00074.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: filters.hh File Reference │ │ │ │ +dune-typetree: visitor.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -71,70 +71,109 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ Classes | │ │ │ │ -Namespaces
    │ │ │ │ -
    filters.hh File Reference
    │ │ │ │ +Namespaces | │ │ │ │ +Functions | │ │ │ │ +Variables
    │ │ │ │ +
    visitor.hh File Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ -
    #include <tuple>
    │ │ │ │ -#include <dune/common/typetraits.hh>
    │ │ │ │ +
    #include <dune/typetree/treepath.hh>
    │ │ │ │ +#include <dune/common/hybridutilities.hh>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
    │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  Dune::TypeTree::FilterEntry< new_k, old_k >
     A filter entry describing the mapping of one child in the filtered node. More...
    struct  Dune::TypeTree::DefaultVisitor
     Visitor interface and base class for TypeTree visitors. More...
     
    struct  Dune::TypeTree::FilterResult< FilterEntries >
     The result of a filter. More...
    struct  Dune::TypeTree::DefaultPairVisitor
     Visitor interface and base class for visitors of pairs of TypeTrees. More...
     
    struct  Dune::TypeTree::FilterResult< FilterEntries >::apply< Node >
    struct  Dune::TypeTree::Experimental::DefaultHybridVisitor
     Hybrid visitor interface and base class for TypeTree hybrid visitors. More...
     
    struct  Dune::TypeTree::SimpleFilterTag
     Tag describing a simple filter that can only decide whether or not to include a single given child. More...
    struct  Dune::TypeTree::VisitDirectChildren
     Mixin base class for visitors that only want to visit the direct children of a node. More...
     
    struct  Dune::TypeTree::AdvancedFilterTag
     Tag describing an advanced filter that has full control over the construction of the list of FilterEntries. More...
    struct  Dune::TypeTree::VisitDirectChildren::VisitChild< Node1, Child1, Node2, Child2, TreePath >
     Template struct for determining whether or not to visit a given child. More...
     
    struct  Dune::TypeTree::AdvancedFilter
     Base class for advanced filters. More...
    struct  Dune::TypeTree::VisitTree
     Mixin base class for visitors that want to visit the complete tree. More...
     
    struct  Dune::TypeTree::AdvancedFilter::apply< Node, Children >
     Apply this filter to the given node and children. More...
    struct  Dune::TypeTree::VisitTree::VisitChild< Node1, Child1, Node2, Child2, TreePath >
     Template struct for determining whether or not to visit a given child. More...
     
    struct  Dune::TypeTree::SimpleFilter
     Default simple filter that accepts any node and leaves its child structure unchanged. More...
    struct  Dune::TypeTree::StaticTraversal
     Mixin base class for visitors that require a static TreePath during traversal. More...
     
    struct  Dune::TypeTree::SimpleFilter::validate< Node >
     Validates the combination of filter and node. More...
    struct  Dune::TypeTree::DynamicTraversal
     Mixin base class for visitors that only need a dynamic TreePath during traversal. More...
     
    struct  Dune::TypeTree::SimpleFilter::apply< Child, new_index, old_index >
     Applies the filter to the given child node. More...
    struct  Dune::TypeTree::TreeVisitor
     Convenience base class for visiting the entire tree. More...
     
    struct  Dune::TypeTree::IndexFilter< indices >
     Filter class for FilteredCompositeNode that selects the children with the given indices. More...
    struct  Dune::TypeTree::DirectChildrenVisitor
     Convenience base class for visiting the direct children of a node. More...
     
    struct  Dune::TypeTree::filter< Filter >
     Adapter class that takes a SimpleFilter, validated it and turns it into an AdvancedFilter. More...
    struct  Dune::TypeTree::TreePairVisitor
     Convenience base class for visiting an entire tree pair. More...
     
    struct  Dune::TypeTree::filter< Filter >::apply< Node, Children >
     Apply the filter. More...
    struct  Dune::TypeTree::DirectChildrenPairVisitor
     Convenience base class for visiting the direct children of a node pair. More...
     
    struct  Dune::TypeTree::Experimental::Info::LeafCounterVisitor
     
    struct  Dune::TypeTree::Experimental::Info::NodeCounterVisitor
     
    struct  Dune::TypeTree::Experimental::Info::DepthVisitor
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
     
    namespace  Dune::TypeTree::Experimental
     
    namespace  Dune::TypeTree::Experimental::Info
     
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +

    │ │ │ │ +Functions

    template<typename Tree >
    auto Dune::TypeTree::Experimental::Info::depth (const Tree &tree)
     The depth of the TypeTree.
     
    template<typename Tree >
    constexpr auto Dune::TypeTree::Experimental::Info::depth ()
     The depth of the Tree.
     
    template<typename Tree >
    auto Dune::TypeTree::Experimental::Info::nodeCount (const Tree &tree)
     The total number of nodes in the Tree.
     
    template<typename Tree >
    auto Dune::TypeTree::Experimental::Info::leafCount (const Tree &tree)
     The number of leaf nodes in the Tree.
     
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │

    │ │ │ │ +Variables

    template<typename Tree >
    constexpr bool Dune::TypeTree::Experimental::Info::isDynamic = std::is_same<std::size_t, decltype(leafCount(std::declval<Tree>()))>{}
     true if any of the nodes in the tree only has dynamic degree.
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,63 +1,106 @@ │ │ │ │ │ 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 │ │ │ │ │ -filters.hh File Reference │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ +_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 | _V_a_r_i_a_b_l_e_s │ │ │ │ │ +visitor.hh File Reference │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_e_e_p_a_t_h_._h_h> │ │ │ │ │ +#include │ │ │ │ │ _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_:_:_F_i_l_t_e_r_E_n_t_r_y_<_ _n_e_w___k_,_ _o_l_d___k_ _> │ │ │ │ │ -  A filter entry describing the mapping of one child in the filtered │ │ │ │ │ - node. _M_o_r_e_._._. │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_V_i_s_i_t_o_r │ │ │ │ │ +  Visitor interface and base class for _T_y_p_e_T_r_e_e visitors. _M_o_r_e_._._. │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_R_e_s_u_l_t_<_ _F_i_l_t_e_r_E_n_t_r_i_e_s_ _> │ │ │ │ │ -  The result of a filter. _M_o_r_e_._._. │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ +  Visitor interface and base class for visitors of pairs of TypeTrees. │ │ │ │ │ + _M_o_r_e_._._. │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_R_e_s_u_l_t_<_ _F_i_l_t_e_r_E_n_t_r_i_e_s_ _>_:_:_a_p_p_l_y_<_ _N_o_d_e_ _> │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r │ │ │ │ │ +  Hybrid visitor interface and base class for _T_y_p_e_T_r_e_e hybrid visitors. │ │ │ │ │ + _M_o_r_e_._._. │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r_T_a_g │ │ │ │ │ -  Tag describing a simple filter that can only decide whether or not to │ │ │ │ │ - include a single given child. _M_o_r_e_._._. │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_D_i_r_e_c_t_C_h_i_l_d_r_e_n │ │ │ │ │ +  Mixin base class for visitors that only want to visit the direct │ │ │ │ │ + children of a node. _M_o_r_e_._._. │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_d_v_a_n_c_e_d_F_i_l_t_e_r_T_a_g │ │ │ │ │ -  Tag describing an advanced filter that has full control over the │ │ │ │ │ - construction of the list of FilterEntries. _M_o_r_e_._._. │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_D_i_r_e_c_t_C_h_i_l_d_r_e_n_:_:_V_i_s_i_t_C_h_i_l_d_<_ _N_o_d_e_1_,_ _C_h_i_l_d_1_,_ _N_o_d_e_2_, │ │ │ │ │ + _C_h_i_l_d_2_,_ _T_r_e_e_P_a_t_h_ _> │ │ │ │ │ +  Template struct for determining whether or not to visit a given child. │ │ │ │ │ + _M_o_r_e_._._. │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_d_v_a_n_c_e_d_F_i_l_t_e_r │ │ │ │ │ -  Base class for advanced filters. _M_o_r_e_._._. │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_T_r_e_e │ │ │ │ │ +  Mixin base class for visitors that want to visit the complete tree. │ │ │ │ │ + _M_o_r_e_._._. │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_d_v_a_n_c_e_d_F_i_l_t_e_r_:_:_a_p_p_l_y_<_ _N_o_d_e_,_ _C_h_i_l_d_r_e_n_ _> │ │ │ │ │ -  Apply this filter to the given node and children. _M_o_r_e_._._. │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_T_r_e_e_:_:_V_i_s_i_t_C_h_i_l_d_<_ _N_o_d_e_1_,_ _C_h_i_l_d_1_,_ _N_o_d_e_2_,_ _C_h_i_l_d_2_, │ │ │ │ │ + _T_r_e_e_P_a_t_h_ _> │ │ │ │ │ +  Template struct for determining whether or not to visit a given child. │ │ │ │ │ + _M_o_r_e_._._. │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r │ │ │ │ │ -  Default simple filter that accepts any node and leaves its child │ │ │ │ │ - structure unchanged. _M_o_r_e_._._. │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_T_r_a_v_e_r_s_a_l │ │ │ │ │ +  Mixin base class for visitors that require a static TreePath during │ │ │ │ │ + traversal. _M_o_r_e_._._. │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r_:_:_v_a_l_i_d_a_t_e_<_ _N_o_d_e_ _> │ │ │ │ │ -  Validates the combination of filter and node. _M_o_r_e_._._. │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_T_r_a_v_e_r_s_a_l │ │ │ │ │ +  Mixin base class for visitors that only need a dynamic TreePath during │ │ │ │ │ + traversal. _M_o_r_e_._._. │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r_:_:_a_p_p_l_y_<_ _C_h_i_l_d_,_ _n_e_w___i_n_d_e_x_,_ _o_l_d___i_n_d_e_x_ _> │ │ │ │ │ -  Applies the filter to the given child node. _M_o_r_e_._._. │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_V_i_s_i_t_o_r │ │ │ │ │ +  Convenience base class for visiting the entire tree. _M_o_r_e_._._. │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_I_n_d_e_x_F_i_l_t_e_r_<_ _i_n_d_i_c_e_s_ _> │ │ │ │ │ -  Filter class for _F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e that selects the children with │ │ │ │ │ - the given indices. _M_o_r_e_._._. │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_i_r_e_c_t_C_h_i_l_d_r_e_n_V_i_s_i_t_o_r │ │ │ │ │ +  Convenience base class for visiting the direct children of a node. │ │ │ │ │ + _M_o_r_e_._._. │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_i_l_t_e_r_<_ _F_i_l_t_e_r_ _> │ │ │ │ │ -  Adapter class that takes a _S_i_m_p_l_e_F_i_l_t_e_r, validated it and turns it │ │ │ │ │ - into an _A_d_v_a_n_c_e_d_F_i_l_t_e_r. _M_o_r_e_._._. │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ +  Convenience base class for visiting an entire tree pair. _M_o_r_e_._._. │ │ │ │ │   │ │ │ │ │ -struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_i_l_t_e_r_<_ _F_i_l_t_e_r_ _>_:_:_a_p_p_l_y_<_ _N_o_d_e_,_ _C_h_i_l_d_r_e_n_ _> │ │ │ │ │ -  Apply the filter. _M_o_r_e_._._. │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_i_r_e_c_t_C_h_i_l_d_r_e_n_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ +  Convenience base class for visiting the direct children of a node │ │ │ │ │ + pair. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_L_e_a_f_C_o_u_n_t_e_r_V_i_s_i_t_o_r │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_N_o_d_e_C_o_u_n_t_e_r_V_i_s_i_t_o_r │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_D_e_p_t_h_V_i_s_i_t_o_r │ │ │ │ │   │ │ │ │ │ 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 │ │ │ │ │ +  │ │ │ │ │ +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_:_:_I_n_f_o │ │ │ │ │ +  │ │ │ │ │ +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_:_:_I_n_f_o_:_:_d_e_p_t_h (const Tree &tree) │ │ │ │ │ +  The depth of the _T_y_p_e_T_r_e_e. │ │ │ │ │ +  │ │ │ │ │ +template │ │ │ │ │ +constexpr 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_:_:_I_n_f_o_:_:_d_e_p_t_h () │ │ │ │ │ +  The depth of the Tree. │ │ │ │ │ +  │ │ │ │ │ +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_:_:_I_n_f_o_:_:_n_o_d_e_C_o_u_n_t (const Tree │ │ │ │ │ + &tree) │ │ │ │ │ +  The total number of nodes in the Tree. │ │ │ │ │ +  │ │ │ │ │ +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_:_:_I_n_f_o_:_:_l_e_a_f_C_o_u_n_t (const Tree │ │ │ │ │ + &tree) │ │ │ │ │ +  The number of leaf nodes in the Tree. │ │ │ │ │ +  │ │ │ │ │ +VVaarriiaabblleess │ │ │ │ │ +template │ │ │ │ │ +constexpr bool  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_i_s_D_y_n_a_m_i_c = std:: │ │ │ │ │ + is_same()))> │ │ │ │ │ + {} │ │ │ │ │ +  true if any of the nodes in the tree only has dynamic degree. │ │ │ │ │ +  │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00074_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: filters.hh Source File │ │ │ │ +dune-typetree: visitor.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,261 +74,385 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -
    filters.hh
    │ │ │ │ +
    visitor.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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_FILTERS_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_FILTERS_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_VISITOR_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_VISITOR_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <tuple>
    │ │ │ │ -
    10
    │ │ │ │ -
    11#include <dune/common/typetraits.hh>
    │ │ │ │ -
    12
    │ │ │ │ -
    13namespace Dune {
    │ │ │ │ -
    14 namespace TypeTree {
    │ │ │ │ -
    15
    │ │ │ │ -
    22 template<std::size_t new_k, std::size_t old_k>
    │ │ │ │ -
    │ │ │ │ -
    23 struct FilterEntry
    │ │ │ │ -
    24 {
    │ │ │ │ -
    25
    │ │ │ │ -
    26#ifndef DOXYGEN
    │ │ │ │ -
    27
    │ │ │ │ -
    28 // The precise contents of this class is an implementation detail.
    │ │ │ │ -
    29
    │ │ │ │ -
    30 static const std::size_t filtered_index = new_k;
    │ │ │ │ -
    31 static const std::size_t original_index = old_k;
    │ │ │ │ -
    32
    │ │ │ │ -
    33#endif // DOXYGEN
    │ │ │ │ -
    34
    │ │ │ │ -
    35 };
    │ │ │ │ -
    │ │ │ │ -
    36
    │ │ │ │ -
    38 template<typename... FilterEntries>
    │ │ │ │ -
    │ │ │ │ -
    39 struct FilterResult
    │ │ │ │ -
    40 {
    │ │ │ │ -
    41
    │ │ │ │ -
    42 static const std::size_t size = sizeof...(FilterEntries);
    │ │ │ │ -
    43
    │ │ │ │ -
    44 typedef std::tuple<FilterEntries...> IndexMap;
    │ │ │ │ -
    45
    │ │ │ │ -
    46 template<typename Node>
    │ │ │ │ -
    │ │ │ │ -
    47 struct apply
    │ │ │ │ -
    48 {
    │ │ │ │ -
    49 typedef std::tuple<typename Node::template Child<FilterEntries::original_index>...> Children;
    │ │ │ │ -
    50 typedef std::tuple<typename Node::template Child<FilterEntries::original_index>::Type...> ChildTypes;
    │ │ │ │ -
    51 typedef std::tuple<std::shared_ptr<typename Node::template Child<FilterEntries::original_index>::Type>...> NodeStorage;
    │ │ │ │ -
    52 };
    │ │ │ │ -
    │ │ │ │ -
    53
    │ │ │ │ -
    54 };
    │ │ │ │ -
    │ │ │ │ -
    55
    │ │ │ │ -
    57 struct SimpleFilterTag {};
    │ │ │ │ -
    58
    │ │ │ │ -
    60 struct AdvancedFilterTag {};
    │ │ │ │ +
    9#include <dune/typetree/treepath.hh>
    │ │ │ │ +
    10#include <dune/common/hybridutilities.hh>
    │ │ │ │ +
    11
    │ │ │ │ +
    12namespace Dune {
    │ │ │ │ +
    13 namespace TypeTree {
    │ │ │ │ +
    14
    │ │ │ │ +
    21
    │ │ │ │ +
    │ │ │ │ +
    48 struct DefaultVisitor
    │ │ │ │ +
    49 {
    │ │ │ │ +
    50
    │ │ │ │ +
    52
    │ │ │ │ +
    59 template<typename T, typename TreePath>
    │ │ │ │ +
    60 void pre(T&&, TreePath) const {}
    │ │ │ │
    61
    │ │ │ │ -
    62
    │ │ │ │ -
    │ │ │ │ -
    64 struct AdvancedFilter
    │ │ │ │ -
    65 {
    │ │ │ │ -
    66
    │ │ │ │ -
    68 typedef AdvancedFilterTag FilterTag;
    │ │ │ │ -
    69
    │ │ │ │ -
    70#ifdef DOXYGEN
    │ │ │ │ -
    71
    │ │ │ │ -
    73 template<typename Node, typename... Children>
    │ │ │ │ -
    │ │ │ │ -
    74 struct apply
    │ │ │ │ -
    75 {
    │ │ │ │ -
    77
    │ │ │ │ -
    80 typedef implementation-defined type;
    │ │ │ │ -
    81 };
    │ │ │ │ -
    │ │ │ │ -
    82
    │ │ │ │ -
    83#endif // DOXYGEN
    │ │ │ │ +
    63
    │ │ │ │ +
    71 template<typename T, typename TreePath>
    │ │ │ │ +
    72 void in(T&&, TreePath) const {}
    │ │ │ │ +
    73
    │ │ │ │ +
    75
    │ │ │ │ +
    82 template<typename T, typename TreePath>
    │ │ │ │ +
    83 void post(T&&, TreePath) const {}
    │ │ │ │
    84
    │ │ │ │ -
    85 };
    │ │ │ │ -
    │ │ │ │
    86
    │ │ │ │ -
    88
    │ │ │ │ -
    │ │ │ │ -
    93 struct SimpleFilter
    │ │ │ │ -
    94 {
    │ │ │ │ -
    95
    │ │ │ │ -
    97 typedef SimpleFilterTag FilterTag;
    │ │ │ │ -
    98
    │ │ │ │ -
    99
    │ │ │ │ -
    101 template<typename Node>
    │ │ │ │ -
    │ │ │ │ -
    102 struct validate
    │ │ │ │ -
    103 {
    │ │ │ │ -
    105 static const bool value = true;
    │ │ │ │ -
    106 };
    │ │ │ │ -
    │ │ │ │ -
    107
    │ │ │ │ -
    109
    │ │ │ │ -
    117 template<typename Child, std::size_t new_index, std::size_t old_index>
    │ │ │ │ -
    │ │ │ │ -
    118 struct apply
    │ │ │ │ -
    119 {
    │ │ │ │ -
    121 static const bool value = true;
    │ │ │ │ -
    122 };
    │ │ │ │ -
    │ │ │ │ +
    92 template<typename T, typename TreePath>
    │ │ │ │ +
    93 void leaf(T&&, TreePath) const {}
    │ │ │ │ +
    94
    │ │ │ │ +
    96
    │ │ │ │ +
    106 template<typename T, typename Child, typename TreePath, typename ChildIndex>
    │ │ │ │ +
    107 void beforeChild(T&&, Child&&, TreePath, ChildIndex) const {}
    │ │ │ │ +
    108
    │ │ │ │ +
    110
    │ │ │ │ +
    121 template<typename T, typename Child, typename TreePath, typename ChildIndex>
    │ │ │ │ +
    122 void afterChild(T&&, Child&&, TreePath, ChildIndex) const {}
    │ │ │ │
    123
    │ │ │ │
    124 };
    │ │ │ │
    │ │ │ │
    125
    │ │ │ │ -
    126 namespace {
    │ │ │ │ -
    127
    │ │ │ │ -
    128 // ********************************************************************************
    │ │ │ │ -
    129 // IndexFilter helpers
    │ │ │ │ -
    130 // ********************************************************************************
    │ │ │ │ -
    131
    │ │ │ │ -
    132 template<typename Node, std::size_t new_index, std::size_t... indices>
    │ │ │ │ -
    133 struct index_filter_helper
    │ │ │ │ -
    134 {
    │ │ │ │ -
    135 template<typename... FilterEntries>
    │ │ │ │ -
    136 struct apply
    │ │ │ │ -
    137 {
    │ │ │ │ -
    138 typedef FilterResult<FilterEntries...> type;
    │ │ │ │ -
    139 };
    │ │ │ │ -
    140 };
    │ │ │ │ -
    141
    │ │ │ │ -
    142 template<typename Node, std::size_t new_index, std::size_t old_index, std::size_t... indices>
    │ │ │ │ -
    143 struct index_filter_helper<Node,new_index,old_index,indices...>
    │ │ │ │ -
    144 {
    │ │ │ │ -
    145 template<typename... FilterEntries>
    │ │ │ │ -
    146 struct apply
    │ │ │ │ -
    147 : public index_filter_helper<Node,new_index+1,indices...>::template apply<FilterEntries...,
    │ │ │ │ -
    148 FilterEntry<new_index,
    │ │ │ │ -
    149 old_index>
    │ │ │ │ -
    150 >
    │ │ │ │ -
    151 {};
    │ │ │ │ -
    152 };
    │ │ │ │ -
    153
    │ │ │ │ -
    154 } // anonymous namespace
    │ │ │ │ -
    155
    │ │ │ │ -
    156
    │ │ │ │ -
    158 template<std::size_t... indices>
    │ │ │ │ -
    │ │ │ │ -
    159 struct IndexFilter
    │ │ │ │ -
    160 : public AdvancedFilter
    │ │ │ │ -
    161 {
    │ │ │ │ -
    162
    │ │ │ │ -
    163#ifndef DOXYGEN
    │ │ │ │ -
    164
    │ │ │ │ -
    165 template<typename Node, typename... Children>
    │ │ │ │ -
    166 struct apply
    │ │ │ │ -
    167 {
    │ │ │ │ -
    168 typedef typename index_filter_helper<Node,0,indices...>::template apply<>::type type;
    │ │ │ │ -
    169 };
    │ │ │ │ -
    170
    │ │ │ │ -
    171#endif // DOXYGEN
    │ │ │ │ -
    172
    │ │ │ │ -
    173 };
    │ │ │ │ -
    │ │ │ │ -
    174
    │ │ │ │ -
    175
    │ │ │ │ -
    176 // ********************************************************************************
    │ │ │ │ -
    177 // filter: Wrapper class for turning a simple filter into an advanced filter
    │ │ │ │ -
    178 // usable by FilteredCompositeNode
    │ │ │ │ -
    179 // ********************************************************************************
    │ │ │ │ -
    180
    │ │ │ │ -
    181 namespace {
    │ │ │ │ -
    182
    │ │ │ │ -
    183 template<typename Filter, std::size_t new_k, std::size_t old_k, typename... tail>
    │ │ │ │ -
    184 struct filter_helper
    │ │ │ │ -
    185 {
    │ │ │ │ -
    186 template<typename... FilterDescriptors>
    │ │ │ │ -
    187 struct apply
    │ │ │ │ -
    188 {
    │ │ │ │ -
    189 typedef FilterResult<FilterDescriptors...> type;
    │ │ │ │ -
    190 };
    │ │ │ │ -
    191 };
    │ │ │ │ +
    126
    │ │ │ │ +
    128
    │ │ │ │ +
    │ │ │ │ +
    163 struct DefaultPairVisitor
    │ │ │ │ +
    164 {
    │ │ │ │ +
    165
    │ │ │ │ +
    167
    │ │ │ │ +
    175 template<typename T1, typename T2, typename TreePath>
    │ │ │ │ +
    176 void pre(T1&&, T2&&, TreePath) const {}
    │ │ │ │ +
    177
    │ │ │ │ +
    179
    │ │ │ │ +
    188 template<typename T1, typename T2, typename TreePath>
    │ │ │ │ +
    189 void in(T1&&, T2&&, TreePath) const {}
    │ │ │ │ +
    190
    │ │ │ │
    192
    │ │ │ │ -
    193 template<typename Filter, std::size_t new_k, std::size_t old_k, typename child, typename... tail>
    │ │ │ │ -
    194 struct filter_helper<Filter,new_k,old_k,child,tail...>
    │ │ │ │ -
    195 {
    │ │ │ │ -
    196
    │ │ │ │ -
    197 template<typename... FilterDescriptors>
    │ │ │ │ -
    198 struct apply
    │ │ │ │ -
    199 : public std::conditional<Filter::template apply<child,new_k,old_k>::value,
    │ │ │ │ -
    200 typename filter_helper<Filter,new_k+1,old_k+1,tail...>::template apply<FilterDescriptors...,FilterEntry<new_k,old_k> >,
    │ │ │ │ -
    201 typename filter_helper<Filter,new_k,old_k+1,tail...>::template apply<FilterDescriptors...>
    │ │ │ │ -
    202 >::type
    │ │ │ │ -
    203 {};
    │ │ │ │ +
    200 template<typename T1, typename T2, typename TreePath>
    │ │ │ │ +
    201 void post(T1&&, T2&&, TreePath) const {}
    │ │ │ │ +
    202
    │ │ │ │
    204
    │ │ │ │ -
    205 };
    │ │ │ │ -
    206
    │ │ │ │ -
    207 } // anonymous namespace
    │ │ │ │ -
    208
    │ │ │ │ -
    210 template<typename Filter>
    │ │ │ │ -
    │ │ │ │ -
    211 struct filter
    │ │ │ │ -
    212 {
    │ │ │ │ -
    213
    │ │ │ │ -
    215 template<typename Node, typename... Children>
    │ │ │ │ -
    │ │ │ │ -
    216 struct apply
    │ │ │ │ -
    217 {
    │ │ │ │ -
    218
    │ │ │ │ -
    219 static_assert((Filter::template validate<Node>::value),"Invalid simple filter");
    │ │ │ │ -
    220
    │ │ │ │ -
    221 typedef typename filter_helper<Filter,0,0,Children...>::template apply<>::type type;
    │ │ │ │ -
    222
    │ │ │ │ -
    223 };
    │ │ │ │ -
    │ │ │ │ -
    224
    │ │ │ │ -
    225 };
    │ │ │ │ -
    │ │ │ │ -
    226
    │ │ │ │ -
    228
    │ │ │ │ -
    229 } // namespace TypeTree
    │ │ │ │ -
    230} //namespace Dune
    │ │ │ │ -
    231
    │ │ │ │ -
    232#endif // DUNE_TYPETREE_FILTERS_HH
    │ │ │ │ -
    Dune::TypeTree::child
    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
    │ │ │ │ +
    215 template<typename T1, typename T2, typename TreePath>
    │ │ │ │ +
    216 void leaf(T1&&, T2&&, TreePath) const {}
    │ │ │ │ +
    217
    │ │ │ │ +
    219
    │ │ │ │ +
    231 template<typename T1, typename Child1, typename T2, typename Child2, typename TreePath, typename ChildIndex>
    │ │ │ │ +
    232 void beforeChild(T1&&, Child1&&, T2&&, Child2&&, TreePath, ChildIndex) const {}
    │ │ │ │ +
    233
    │ │ │ │ +
    235
    │ │ │ │ +
    247 template<typename T1, typename Child1, typename T2, typename Child2, typename TreePath, typename ChildIndex>
    │ │ │ │ +
    248 void afterChild(T1&&, Child1&&, T2&&, Child2&&, TreePath, ChildIndex) const {}
    │ │ │ │ +
    249
    │ │ │ │ +
    250 };
    │ │ │ │ +
    │ │ │ │ +
    251
    │ │ │ │ +
    252
    │ │ │ │ +
    253 namespace Experimental {
    │ │ │ │ +
    254
    │ │ │ │ +
    │ │ │ │ +
    285 struct DefaultHybridVisitor
    │ │ │ │ +
    286 {
    │ │ │ │ +
    287
    │ │ │ │ +
    295 template<typename T, typename TreePath, typename U>
    │ │ │ │ +
    296 auto pre(T&&, TreePath, const U& u) const { return u;}
    │ │ │ │ +
    297
    │ │ │ │ +
    305 template<typename T, typename TreePath, typename U>
    │ │ │ │ +
    306 auto in(T&&, TreePath, const U& u) const {return u;}
    │ │ │ │ +
    307
    │ │ │ │ +
    315 template<typename T, typename TreePath, typename U>
    │ │ │ │ +
    316 auto post(T&&, TreePath, const U& u) const {return u;}
    │ │ │ │ +
    317
    │ │ │ │ +
    325 template<typename T, typename TreePath, typename U>
    │ │ │ │ +
    326 auto leaf(T&&, TreePath, const U& u) const { return u;}
    │ │ │ │ +
    327
    │ │ │ │ +
    335 template<typename T, typename Child, typename TreePath, typename ChildIndex, typename U>
    │ │ │ │ +
    336 auto beforeChild(T&&, Child&&, TreePath, ChildIndex, const U& u) const {return u;}
    │ │ │ │ +
    337
    │ │ │ │ +
    345 template<typename T, typename Child, typename TreePath, typename ChildIndex, typename U>
    │ │ │ │ +
    346 auto afterChild(T&&, Child&&, TreePath, ChildIndex, const U& u) const {return u;}
    │ │ │ │ +
    347
    │ │ │ │ +
    348 };
    │ │ │ │ +
    │ │ │ │ +
    349 } // namespace Experimental
    │ │ │ │ +
    350
    │ │ │ │ +
    352
    │ │ │ │ +
    │ │ │ │ +
    357 struct VisitDirectChildren
    │ │ │ │ +
    358 {
    │ │ │ │ +
    359
    │ │ │ │ +
    360 // the little trick with the default template arguments
    │ │ │ │ +
    361 // makes the class usable for both single-tree visitors
    │ │ │ │ +
    362 // and visitors for pairs of trees
    │ │ │ │ +
    364 template<typename Node1,
    │ │ │ │ +
    365 typename Child1,
    │ │ │ │ +
    366 typename Node2,
    │ │ │ │ +
    367 typename Child2 = void,
    │ │ │ │ +
    368 typename TreePath = void>
    │ │ │ │ +
    │ │ │ │ +
    369 struct VisitChild
    │ │ │ │ +
    370 {
    │ │ │ │ +
    372 static const bool value = false;
    │ │ │ │ +
    373 };
    │ │ │ │ +
    │ │ │ │ +
    374
    │ │ │ │ +
    375 };
    │ │ │ │ +
    │ │ │ │ +
    376
    │ │ │ │ +
    377
    │ │ │ │ +
    379
    │ │ │ │ +
    │ │ │ │ +
    383 struct VisitTree
    │ │ │ │ +
    384 {
    │ │ │ │ +
    385
    │ │ │ │ +
    386 // the little trick with the default template arguments
    │ │ │ │ +
    387 // makes the class usable for both single-tree visitors
    │ │ │ │ +
    388 // and visitors for pairs of trees
    │ │ │ │ +
    390 template<typename Node1,
    │ │ │ │ +
    391 typename Child1,
    │ │ │ │ +
    392 typename Node2,
    │ │ │ │ +
    393 typename Child2 = void,
    │ │ │ │ +
    394 typename TreePath = void>
    │ │ │ │ +
    │ │ │ │ +
    395 struct VisitChild
    │ │ │ │ +
    396 {
    │ │ │ │ +
    398 static const bool value = true;
    │ │ │ │ +
    399 };
    │ │ │ │ +
    │ │ │ │ +
    400
    │ │ │ │ +
    401 };
    │ │ │ │ +
    │ │ │ │ +
    402
    │ │ │ │ +
    404
    │ │ │ │ +
    │ │ │ │ +
    411 struct StaticTraversal
    │ │ │ │ +
    412 {
    │ │ │ │ +
    414 static const TreePathType::Type treePathType = TreePathType::fullyStatic;
    │ │ │ │ +
    415 };
    │ │ │ │ +
    │ │ │ │ +
    416
    │ │ │ │ +
    418
    │ │ │ │ +
    │ │ │ │ +
    425 struct DynamicTraversal
    │ │ │ │ +
    426 {
    │ │ │ │ +
    428 static const TreePathType::Type treePathType = TreePathType::dynamic;
    │ │ │ │ +
    429 };
    │ │ │ │ +
    │ │ │ │ +
    430
    │ │ │ │ +
    │ │ │ │ +
    432 struct TreeVisitor
    │ │ │ │ +
    433 : public DefaultVisitor
    │ │ │ │ +
    434 , public VisitTree
    │ │ │ │ +
    435 {};
    │ │ │ │ +
    │ │ │ │ +
    436
    │ │ │ │ +
    │ │ │ │ +
    438 struct DirectChildrenVisitor
    │ │ │ │ +
    439 : public DefaultVisitor
    │ │ │ │ +
    440 , public VisitDirectChildren
    │ │ │ │ +
    441 {};
    │ │ │ │ +
    │ │ │ │ +
    442
    │ │ │ │ +
    │ │ │ │ +
    444 struct TreePairVisitor
    │ │ │ │ +
    445 : public DefaultPairVisitor
    │ │ │ │ +
    446 , public VisitTree
    │ │ │ │ +
    447 {};
    │ │ │ │ +
    │ │ │ │ +
    448
    │ │ │ │ +
    │ │ │ │ +
    450 struct DirectChildrenPairVisitor
    │ │ │ │ +
    451 : public DefaultPairVisitor
    │ │ │ │ +
    452 , public VisitDirectChildren
    │ │ │ │ +
    453 {};
    │ │ │ │ +
    │ │ │ │ +
    454
    │ │ │ │ +
    │ │ │ │ +
    455 namespace Experimental::Info {
    │ │ │ │ +
    456
    │ │ │ │ +
    │ │ │ │ +
    457 struct LeafCounterVisitor
    │ │ │ │ +
    458 : public DefaultHybridVisitor
    │ │ │ │ +
    459 , public StaticTraversal
    │ │ │ │ +
    460 , public VisitTree
    │ │ │ │ +
    461 {
    │ │ │ │ +
    462 template<class Tree, class Child, class TreePath, class ChildIndex, class U>
    │ │ │ │ +
    │ │ │ │ +
    463 auto beforeChild(Tree&&, Child&&, TreePath, ChildIndex, U u) const {
    │ │ │ │ +
    464 // in this case child index is an integral constant: forward u
    │ │ │ │ +
    465 return u;
    │ │ │ │ +
    466 }
    │ │ │ │ +
    │ │ │ │ +
    467
    │ │ │ │ +
    468 template<class Tree, class Child, class TreePath, class U>
    │ │ │ │ +
    │ │ │ │ +
    469 std::size_t beforeChild(Tree&&, Child&&, TreePath, std::size_t /*childIndex*/, U u) const {
    │ │ │ │ +
    470 // in this case child index is a run-time index: cast accumulated u to std::size_t
    │ │ │ │ +
    471 return std::size_t{u};
    │ │ │ │ +
    472 }
    │ │ │ │ +
    │ │ │ │ +
    473
    │ │ │ │ +
    474 template<class Tree, class TreePath, class U>
    │ │ │ │ +
    │ │ │ │ +
    475 auto leaf(Tree&&, TreePath, U u) const
    │ │ │ │ +
    476 {
    │ │ │ │ +
    477 return Hybrid::plus(u,Dune::Indices::_1);
    │ │ │ │ +
    478 }
    │ │ │ │ +
    │ │ │ │ +
    479
    │ │ │ │ +
    480 };
    │ │ │ │ +
    │ │ │ │ +
    481
    │ │ │ │ +
    │ │ │ │ +
    482 struct NodeCounterVisitor
    │ │ │ │ +
    483 : public LeafCounterVisitor
    │ │ │ │ +
    484 {
    │ │ │ │ +
    485 template<typename Tree, typename TreePath, typename U>
    │ │ │ │ +
    │ │ │ │ +
    486 auto pre(Tree&&, TreePath, U u) const {
    │ │ │ │ +
    487 return Hybrid::plus(u,Indices::_1);
    │ │ │ │ +
    488 }
    │ │ │ │ +
    │ │ │ │ +
    489 };
    │ │ │ │ +
    │ │ │ │ +
    490
    │ │ │ │ +
    │ │ │ │ +
    491 struct DepthVisitor
    │ │ │ │ +
    492 : public DefaultHybridVisitor
    │ │ │ │ +
    493 , public StaticTraversal
    │ │ │ │ +
    494 , public VisitTree
    │ │ │ │ +
    495 {
    │ │ │ │ +
    496 template<class Tree, class TreePath, class U>
    │ │ │ │ +
    │ │ │ │ +
    497 auto leaf(Tree&&, TreePath, U u) const
    │ │ │ │ +
    498 {
    │ │ │ │ +
    499 auto path_size = index_constant<treePathSize(TreePath{})>{};
    │ │ │ │ +
    500 auto depth = Hybrid::plus(path_size,Indices::_1);
    │ │ │ │ +
    501 return Hybrid::max(depth,u);
    │ │ │ │ +
    502 }
    │ │ │ │ +
    │ │ │ │ +
    503 };
    │ │ │ │ +
    │ │ │ │ +
    504
    │ │ │ │ +
    506 // result is alwayas an integral constant
    │ │ │ │ +
    507 template<typename Tree>
    │ │ │ │ +
    │ │ │ │ +
    508 auto depth(const Tree& tree)
    │ │ │ │ +
    509 {
    │ │ │ │ +
    510 return hybridApplyToTree(tree,DepthVisitor{},Indices::_0);
    │ │ │ │ +
    511 }
    │ │ │ │ +
    │ │ │ │ +
    512
    │ │ │ │ +
    514 // return types is std::integral_constant.
    │ │ │ │ +
    515 template<typename Tree>
    │ │ │ │ +
    │ │ │ │ +
    516 constexpr auto depth()
    │ │ │ │ +
    517 {
    │ │ │ │ +
    518 return decltype(hybridApplyToTree(std::declval<Tree>(),DepthVisitor{},Indices::_0)){};
    │ │ │ │ +
    519 }
    │ │ │ │ +
    │ │ │ │ +
    520
    │ │ │ │ +
    522 // if Tree is dynamic, return type is std::size_t, otherwise std::integral_constant.
    │ │ │ │ +
    523 template<typename Tree>
    │ │ │ │ +
    │ │ │ │ +
    524 auto nodeCount(const Tree& tree)
    │ │ │ │ +
    525 {
    │ │ │ │ +
    526 return hybridApplyToTree(tree,NodeCounterVisitor{},Indices::_0);
    │ │ │ │ +
    527 }
    │ │ │ │ +
    │ │ │ │ +
    528
    │ │ │ │ +
    530 // if Tree is dynamic, return type is std::size_t, otherwise std::integral_constant.
    │ │ │ │ +
    531 template<typename Tree>
    │ │ │ │ +
    │ │ │ │ +
    532 auto leafCount(const Tree& tree)
    │ │ │ │ +
    533 {
    │ │ │ │ +
    534 return hybridApplyToTree(tree,LeafCounterVisitor{},Dune::Indices::_0);
    │ │ │ │ +
    535 }
    │ │ │ │ +
    │ │ │ │ +
    536
    │ │ │ │ +
    538 template<typename Tree>
    │ │ │ │ +
    539 constexpr bool isDynamic = std::is_same<std::size_t, decltype(leafCount(std::declval<Tree>()))>{};
    │ │ │ │ +
    540
    │ │ │ │ +
    541 } // namespace Experimental::Info
    │ │ │ │ +
    │ │ │ │ +
    542
    │ │ │ │ +
    544
    │ │ │ │ +
    545 } // namespace TypeTree
    │ │ │ │ +
    546} //namespace Dune
    │ │ │ │ +
    547
    │ │ │ │ +
    548#endif // DUNE_TYPETREE_VISITOR_HH
    │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::Child
    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
    │ │ │ │ +
    Dune::TypeTree::treePathSize
    constexpr std::size_t treePathSize(const HybridTreePath< T... > &)
    Returns the size (number of components) of the given HybridTreePath.
    Definition treepath.hh:334
    │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::FilterEntry
    A filter entry describing the mapping of one child in the filtered node.
    Definition filters.hh:24
    │ │ │ │ -
    Dune::TypeTree::FilterResult
    The result of a filter.
    Definition filters.hh:40
    │ │ │ │ -
    Dune::TypeTree::FilterResult::IndexMap
    std::tuple< FilterEntries... > IndexMap
    Definition filters.hh:44
    │ │ │ │ -
    Dune::TypeTree::FilterResult::size
    static const std::size_t size
    Definition filters.hh:42
    │ │ │ │ -
    Dune::TypeTree::FilterResult::apply
    Definition filters.hh:48
    │ │ │ │ -
    Dune::TypeTree::FilterResult::apply::Children
    std::tuple< typename Node::template Child< FilterEntries::original_index >... > Children
    Definition filters.hh:49
    │ │ │ │ -
    Dune::TypeTree::FilterResult::apply::ChildTypes
    std::tuple< typename Node::template Child< FilterEntries::original_index >::Type... > ChildTypes
    Definition filters.hh:50
    │ │ │ │ -
    Dune::TypeTree::FilterResult::apply::NodeStorage
    std::tuple< std::shared_ptr< typename Node::template Child< FilterEntries::original_index >::Type >... > NodeStorage
    Definition filters.hh:51
    │ │ │ │ -
    Dune::TypeTree::SimpleFilterTag
    Tag describing a simple filter that can only decide whether or not to include a single given child.
    Definition filters.hh:57
    │ │ │ │ -
    Dune::TypeTree::AdvancedFilterTag
    Tag describing an advanced filter that has full control over the construction of the list of FilterEn...
    Definition filters.hh:60
    │ │ │ │ -
    Dune::TypeTree::AdvancedFilter
    Base class for advanced filters.
    Definition filters.hh:65
    │ │ │ │ -
    Dune::TypeTree::AdvancedFilter::FilterTag
    AdvancedFilterTag FilterTag
    Filter tag for deciding on filter application mechanism.
    Definition filters.hh:68
    │ │ │ │ -
    Dune::TypeTree::AdvancedFilter::apply
    Apply this filter to the given node and children.
    Definition filters.hh:75
    │ │ │ │ -
    Dune::TypeTree::AdvancedFilter::apply::type
    implementation defined type
    The result of the filtering process.
    Definition filters.hh:80
    │ │ │ │ -
    Dune::TypeTree::SimpleFilter
    Default simple filter that accepts any node and leaves its child structure unchanged.
    Definition filters.hh:94
    │ │ │ │ -
    Dune::TypeTree::SimpleFilter::FilterTag
    SimpleFilterTag FilterTag
    Filter tag for deciding on filter application mechanism.
    Definition filters.hh:97
    │ │ │ │ -
    Dune::TypeTree::SimpleFilter::validate
    Validates the combination of filter and node.
    Definition filters.hh:103
    │ │ │ │ -
    Dune::TypeTree::SimpleFilter::validate::value
    static const bool value
    True if the combination of filter and node is valid.
    Definition filters.hh:105
    │ │ │ │ -
    Dune::TypeTree::SimpleFilter::apply
    Applies the filter to the given child node.
    Definition filters.hh:119
    │ │ │ │ -
    Dune::TypeTree::SimpleFilter::apply::value
    static const bool value
    True if the child will be included in the filtered node.
    Definition filters.hh:121
    │ │ │ │ -
    Dune::TypeTree::IndexFilter
    Filter class for FilteredCompositeNode that selects the children with the given indices.
    Definition filters.hh:161
    │ │ │ │ -
    Dune::TypeTree::filter
    Adapter class that takes a SimpleFilter, validated it and turns it into an AdvancedFilter.
    Definition filters.hh:212
    │ │ │ │ -
    Dune::TypeTree::filter::apply
    Apply the filter.
    Definition filters.hh:217
    │ │ │ │ -
    Dune::TypeTree::filter::apply::type
    filter_helper< Filter, 0, 0, Children... >::template apply ::type type
    Definition filters.hh:221
    │ │ │ │ +
    Dune::TypeTree::Experimental::hybridApplyToTree
    auto hybridApplyToTree(Tree &&tree, Visitor &&visitor, Init &&init)
    Apply hybrid visitor to TypeTree.
    Definition accumulate_static.hh:701
    │ │ │ │ +
    Dune::TypeTree::TreePathType::Type
    Type
    Definition treepath.hh:106
    │ │ │ │ +
    Dune::TypeTree::TreePathType::fullyStatic
    @ fullyStatic
    Definition treepath.hh:106
    │ │ │ │ +
    Dune::TypeTree::TreePathType::dynamic
    @ dynamic
    Definition treepath.hh:106
    │ │ │ │ +
    Dune::TypeTree::Experimental::Info::isDynamic
    constexpr bool isDynamic
    true if any of the nodes in the tree only has dynamic degree.
    Definition visitor.hh:539
    │ │ │ │ +
    Dune::TypeTree::Experimental::Info::leafCount
    auto leafCount(const Tree &tree)
    The number of leaf nodes in the Tree.
    Definition visitor.hh:532
    │ │ │ │ +
    Dune::TypeTree::Experimental::Info::nodeCount
    auto nodeCount(const Tree &tree)
    The total number of nodes in the Tree.
    Definition visitor.hh:524
    │ │ │ │ +
    Dune::TypeTree::Experimental::Info::depth
    constexpr auto depth()
    The depth of the Tree.
    Definition visitor.hh:516
    │ │ │ │ +
    Dune::TypeTree::DefaultVisitor
    Visitor interface and base class for TypeTree visitors.
    Definition visitor.hh:49
    │ │ │ │ +
    Dune::TypeTree::DefaultVisitor::in
    void in(T &&, TreePath) const
    Method for infix tree traversal.
    Definition visitor.hh:72
    │ │ │ │ +
    Dune::TypeTree::DefaultVisitor::afterChild
    void afterChild(T &&, Child &&, TreePath, ChildIndex) const
    Method for child-parent traversal.
    Definition visitor.hh:122
    │ │ │ │ +
    Dune::TypeTree::DefaultVisitor::beforeChild
    void beforeChild(T &&, Child &&, TreePath, ChildIndex) const
    Method for parent-child traversal.
    Definition visitor.hh:107
    │ │ │ │ +
    Dune::TypeTree::DefaultVisitor::post
    void post(T &&, TreePath) const
    Method for postfix tree traversal.
    Definition visitor.hh:83
    │ │ │ │ +
    Dune::TypeTree::DefaultVisitor::leaf
    void leaf(T &&, TreePath) const
    Method for leaf traversal.
    Definition visitor.hh:93
    │ │ │ │ +
    Dune::TypeTree::DefaultVisitor::pre
    void pre(T &&, TreePath) const
    Method for prefix tree traversal.
    Definition visitor.hh:60
    │ │ │ │ +
    Dune::TypeTree::DefaultPairVisitor
    Visitor interface and base class for visitors of pairs of TypeTrees.
    Definition visitor.hh:164
    │ │ │ │ +
    Dune::TypeTree::DefaultPairVisitor::leaf
    void leaf(T1 &&, T2 &&, TreePath) const
    Method for leaf traversal.
    Definition visitor.hh:216
    │ │ │ │ +
    Dune::TypeTree::DefaultPairVisitor::beforeChild
    void beforeChild(T1 &&, Child1 &&, T2 &&, Child2 &&, TreePath, ChildIndex) const
    Method for parent-child traversal.
    Definition visitor.hh:232
    │ │ │ │ +
    Dune::TypeTree::DefaultPairVisitor::pre
    void pre(T1 &&, T2 &&, TreePath) const
    Method for prefix tree traversal.
    Definition visitor.hh:176
    │ │ │ │ +
    Dune::TypeTree::DefaultPairVisitor::post
    void post(T1 &&, T2 &&, TreePath) const
    Method for postfix traversal.
    Definition visitor.hh:201
    │ │ │ │ +
    Dune::TypeTree::DefaultPairVisitor::in
    void in(T1 &&, T2 &&, TreePath) const
    Method for infix tree traversal.
    Definition visitor.hh:189
    │ │ │ │ +
    Dune::TypeTree::DefaultPairVisitor::afterChild
    void afterChild(T1 &&, Child1 &&, T2 &&, Child2 &&, TreePath, ChildIndex) const
    Method for child-parent traversal.
    Definition visitor.hh:248
    │ │ │ │ +
    Dune::TypeTree::Experimental::DefaultHybridVisitor
    Hybrid visitor interface and base class for TypeTree hybrid visitors.
    Definition visitor.hh:286
    │ │ │ │ +
    Dune::TypeTree::Experimental::DefaultHybridVisitor::post
    auto post(T &&, TreePath, const U &u) const
    Method for postfix tree traversal.
    Definition visitor.hh:316
    │ │ │ │ +
    Dune::TypeTree::Experimental::DefaultHybridVisitor::pre
    auto pre(T &&, TreePath, const U &u) const
    Method for prefix tree traversal.
    Definition visitor.hh:296
    │ │ │ │ +
    Dune::TypeTree::Experimental::DefaultHybridVisitor::leaf
    auto leaf(T &&, TreePath, const U &u) const
    Method for leaf traversal.
    Definition visitor.hh:326
    │ │ │ │ +
    Dune::TypeTree::Experimental::DefaultHybridVisitor::afterChild
    auto afterChild(T &&, Child &&, TreePath, ChildIndex, const U &u) const
    Method for child-parent traversal.
    Definition visitor.hh:346
    │ │ │ │ +
    Dune::TypeTree::Experimental::DefaultHybridVisitor::in
    auto in(T &&, TreePath, const U &u) const
    Method for infix tree traversal.
    Definition visitor.hh:306
    │ │ │ │ +
    Dune::TypeTree::Experimental::DefaultHybridVisitor::beforeChild
    auto beforeChild(T &&, Child &&, TreePath, ChildIndex, const U &u) const
    Method for parent-child traversal.
    Definition visitor.hh:336
    │ │ │ │ +
    Dune::TypeTree::VisitDirectChildren
    Mixin base class for visitors that only want to visit the direct children of a node.
    Definition visitor.hh:358
    │ │ │ │ +
    Dune::TypeTree::VisitDirectChildren::VisitChild
    Template struct for determining whether or not to visit a given child.
    Definition visitor.hh:370
    │ │ │ │ +
    Dune::TypeTree::VisitDirectChildren::VisitChild::value
    static const bool value
    Do not visit any child.
    Definition visitor.hh:372
    │ │ │ │ +
    Dune::TypeTree::VisitTree
    Mixin base class for visitors that want to visit the complete tree.
    Definition visitor.hh:384
    │ │ │ │ +
    Dune::TypeTree::VisitTree::VisitChild
    Template struct for determining whether or not to visit a given child.
    Definition visitor.hh:396
    │ │ │ │ +
    Dune::TypeTree::VisitTree::VisitChild::value
    static const bool value
    Visit any child.
    Definition visitor.hh:398
    │ │ │ │ +
    Dune::TypeTree::StaticTraversal
    Mixin base class for visitors that require a static TreePath during traversal.
    Definition visitor.hh:412
    │ │ │ │ +
    Dune::TypeTree::StaticTraversal::treePathType
    static const TreePathType::Type treePathType
    Use the static tree traversal algorithm.
    Definition visitor.hh:414
    │ │ │ │ +
    Dune::TypeTree::DynamicTraversal
    Mixin base class for visitors that only need a dynamic TreePath during traversal.
    Definition visitor.hh:426
    │ │ │ │ +
    Dune::TypeTree::DynamicTraversal::treePathType
    static const TreePathType::Type treePathType
    Use the dynamic tree traversal algorithm.
    Definition visitor.hh:428
    │ │ │ │ +
    Dune::TypeTree::TreeVisitor
    Convenience base class for visiting the entire tree.
    Definition visitor.hh:435
    │ │ │ │ +
    Dune::TypeTree::DirectChildrenVisitor
    Convenience base class for visiting the direct children of a node.
    Definition visitor.hh:441
    │ │ │ │ +
    Dune::TypeTree::TreePairVisitor
    Convenience base class for visiting an entire tree pair.
    Definition visitor.hh:447
    │ │ │ │ +
    Dune::TypeTree::DirectChildrenPairVisitor
    Convenience base class for visiting the direct children of a node pair.
    Definition visitor.hh:453
    │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::Experimental::Info::LeafCounterVisitor::leaf
    auto leaf(Tree &&, TreePath, U u) const
    Definition visitor.hh:475
    │ │ │ │ +
    Dune::TypeTree::Experimental::Info::LeafCounterVisitor::beforeChild
    auto beforeChild(Tree &&, Child &&, TreePath, ChildIndex, U u) const
    Definition visitor.hh:463
    │ │ │ │ +
    Dune::TypeTree::Experimental::Info::LeafCounterVisitor::beforeChild
    std::size_t beforeChild(Tree &&, Child &&, TreePath, std::size_t, U u) const
    Definition visitor.hh:469
    │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::Experimental::Info::NodeCounterVisitor::pre
    auto pre(Tree &&, TreePath, U u) const
    Definition visitor.hh:486
    │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::Experimental::Info::DepthVisitor::leaf
    auto leaf(Tree &&, TreePath, U u) const
    Definition visitor.hh:497
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,320 +1,481 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -filters.hh │ │ │ │ │ +visitor.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_FILTERS_HH │ │ │ │ │ -7#define DUNE_TYPETREE_FILTERS_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_VISITOR_HH │ │ │ │ │ +7#define DUNE_TYPETREE_VISITOR_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include │ │ │ │ │ -10 │ │ │ │ │ -11#include │ │ │ │ │ -12 │ │ │ │ │ -13namespace _D_u_n_e { │ │ │ │ │ -14 namespace TypeTree { │ │ │ │ │ -15 │ │ │ │ │ -22 template │ │ │ │ │ -_2_3 struct _F_i_l_t_e_r_E_n_t_r_y │ │ │ │ │ -24 { │ │ │ │ │ -25 │ │ │ │ │ -26#ifndef DOXYGEN │ │ │ │ │ -27 │ │ │ │ │ -28 // The precise contents of this class is an implementation detail. │ │ │ │ │ -29 │ │ │ │ │ -30 static const std::size_t filtered_index = new_k; │ │ │ │ │ -31 static const std::size_t original_index = old_k; │ │ │ │ │ -32 │ │ │ │ │ -33#endif // DOXYGEN │ │ │ │ │ -34 │ │ │ │ │ -35 }; │ │ │ │ │ -36 │ │ │ │ │ -38 template │ │ │ │ │ -_3_9 struct _F_i_l_t_e_r_R_e_s_u_l_t │ │ │ │ │ -40 { │ │ │ │ │ -41 │ │ │ │ │ -_4_2 static const std::size_t _s_i_z_e = sizeof...(FilterEntries); │ │ │ │ │ -43 │ │ │ │ │ -_4_4 typedef std::tuple _I_n_d_e_x_M_a_p; │ │ │ │ │ -45 │ │ │ │ │ -46 template │ │ │ │ │ -_4_7 struct _a_p_p_l_y │ │ │ │ │ -48 { │ │ │ │ │ -_4_9 typedef std::tuple...> _C_h_i_l_d_r_e_n; │ │ │ │ │ -_5_0 typedef std::tuple::Type...> _C_h_i_l_d_T_y_p_e_s; │ │ │ │ │ -_5_1 typedef std::tuple::Type>...> _N_o_d_e_S_t_o_r_a_g_e; │ │ │ │ │ -52 }; │ │ │ │ │ -53 │ │ │ │ │ -54 }; │ │ │ │ │ -55 │ │ │ │ │ -_5_7 struct _S_i_m_p_l_e_F_i_l_t_e_r_T_a_g {}; │ │ │ │ │ -58 │ │ │ │ │ -_6_0 struct _A_d_v_a_n_c_e_d_F_i_l_t_e_r_T_a_g {}; │ │ │ │ │ +9#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_e_e_p_a_t_h_._h_h> │ │ │ │ │ +10#include │ │ │ │ │ +11 │ │ │ │ │ +12namespace _D_u_n_e { │ │ │ │ │ +13 namespace TypeTree { │ │ │ │ │ +14 │ │ │ │ │ +21 │ │ │ │ │ +_4_8 struct _D_e_f_a_u_l_t_V_i_s_i_t_o_r │ │ │ │ │ +49 { │ │ │ │ │ +50 │ │ │ │ │ +52 │ │ │ │ │ +59 template │ │ │ │ │ +_6_0 void _p_r_e(T&&, TreePath) const {} │ │ │ │ │ 61 │ │ │ │ │ -62 │ │ │ │ │ -_6_4 struct _A_d_v_a_n_c_e_d_F_i_l_t_e_r │ │ │ │ │ -65 { │ │ │ │ │ -66 │ │ │ │ │ -_6_8 typedef _A_d_v_a_n_c_e_d_F_i_l_t_e_r_T_a_g _F_i_l_t_e_r_T_a_g; │ │ │ │ │ -69 │ │ │ │ │ -70#ifdef DOXYGEN │ │ │ │ │ -71 │ │ │ │ │ -73 template │ │ │ │ │ -_7_4 struct _a_p_p_l_y │ │ │ │ │ -75 { │ │ │ │ │ -77 │ │ │ │ │ -_8_0 typedef implementation-defined _t_y_p_e; │ │ │ │ │ -81 }; │ │ │ │ │ -82 │ │ │ │ │ -83#endif // DOXYGEN │ │ │ │ │ +63 │ │ │ │ │ +71 template │ │ │ │ │ +_7_2 void _i_n(T&&, TreePath) const {} │ │ │ │ │ +73 │ │ │ │ │ +75 │ │ │ │ │ +82 template │ │ │ │ │ +_8_3 void _p_o_s_t(T&&, TreePath) const {} │ │ │ │ │ 84 │ │ │ │ │ -85 }; │ │ │ │ │ 86 │ │ │ │ │ -88 │ │ │ │ │ -_9_3 struct _S_i_m_p_l_e_F_i_l_t_e_r │ │ │ │ │ -94 { │ │ │ │ │ -95 │ │ │ │ │ -_9_7 typedef _S_i_m_p_l_e_F_i_l_t_e_r_T_a_g _F_i_l_t_e_r_T_a_g; │ │ │ │ │ -98 │ │ │ │ │ -99 │ │ │ │ │ -101 template │ │ │ │ │ -_1_0_2 struct _v_a_l_i_d_a_t_e │ │ │ │ │ -103 { │ │ │ │ │ -_1_0_5 static const bool _v_a_l_u_e = true; │ │ │ │ │ -106 }; │ │ │ │ │ -107 │ │ │ │ │ -109 │ │ │ │ │ -117 template │ │ │ │ │ -_1_1_8 struct _a_p_p_l_y │ │ │ │ │ -119 { │ │ │ │ │ -_1_2_1 static const bool _v_a_l_u_e = true; │ │ │ │ │ -122 }; │ │ │ │ │ +92 template │ │ │ │ │ +_9_3 void _l_e_a_f(T&&, TreePath) const {} │ │ │ │ │ +94 │ │ │ │ │ +96 │ │ │ │ │ +106 template │ │ │ │ │ +_1_0_7 void _b_e_f_o_r_e_C_h_i_l_d(T&&, _C_h_i_l_d&&, TreePath, ChildIndex) const {} │ │ │ │ │ +108 │ │ │ │ │ +110 │ │ │ │ │ +121 template │ │ │ │ │ +_1_2_2 void _a_f_t_e_r_C_h_i_l_d(T&&, _C_h_i_l_d&&, TreePath, ChildIndex) const {} │ │ │ │ │ 123 │ │ │ │ │ 124 }; │ │ │ │ │ 125 │ │ │ │ │ -126 namespace { │ │ │ │ │ -127 │ │ │ │ │ -128 / │ │ │ │ │ -/ │ │ │ │ │ -******************************************************************************** │ │ │ │ │ -129 // IndexFilter helpers │ │ │ │ │ -130 / │ │ │ │ │ -/ │ │ │ │ │ -******************************************************************************** │ │ │ │ │ -131 │ │ │ │ │ -132 template │ │ │ │ │ -133 struct index_filter_helper │ │ │ │ │ -134 { │ │ │ │ │ -135 template │ │ │ │ │ -136 struct apply │ │ │ │ │ -137 { │ │ │ │ │ -138 typedef _F_i_l_t_e_r_R_e_s_u_l_t type; │ │ │ │ │ -139 }; │ │ │ │ │ -140 }; │ │ │ │ │ -141 │ │ │ │ │ -142 template │ │ │ │ │ -143 struct index_filter_helper │ │ │ │ │ -144 { │ │ │ │ │ -145 template │ │ │ │ │ -146 struct apply │ │ │ │ │ -147 : public index_filter_helper::template │ │ │ │ │ -apply │ │ │ │ │ -150 > │ │ │ │ │ -151 {}; │ │ │ │ │ -152 }; │ │ │ │ │ -153 │ │ │ │ │ -154 } // anonymous namespace │ │ │ │ │ -155 │ │ │ │ │ -156 │ │ │ │ │ -158 template │ │ │ │ │ -_1_5_9 struct _I_n_d_e_x_F_i_l_t_e_r │ │ │ │ │ -160 : public _A_d_v_a_n_c_e_d_F_i_l_t_e_r │ │ │ │ │ -161 { │ │ │ │ │ -162 │ │ │ │ │ -163#ifndef DOXYGEN │ │ │ │ │ -164 │ │ │ │ │ -165 template │ │ │ │ │ -166 struct _a_p_p_l_y │ │ │ │ │ -167 { │ │ │ │ │ -168 typedef typename index_filter_helper::template _a_p_p_l_y_<_>_:_: │ │ │ │ │ -_t_y_p_e _t_y_p_e; │ │ │ │ │ -169 }; │ │ │ │ │ -170 │ │ │ │ │ -171#endif // DOXYGEN │ │ │ │ │ -172 │ │ │ │ │ -173 }; │ │ │ │ │ -174 │ │ │ │ │ -175 │ │ │ │ │ -176 / │ │ │ │ │ -/ │ │ │ │ │ -******************************************************************************** │ │ │ │ │ -177 // filter: Wrapper class for turning a simple filter into an advanced │ │ │ │ │ -filter │ │ │ │ │ -178 // usable by FilteredCompositeNode │ │ │ │ │ -179 / │ │ │ │ │ -/ │ │ │ │ │ -******************************************************************************** │ │ │ │ │ -180 │ │ │ │ │ -181 namespace { │ │ │ │ │ -182 │ │ │ │ │ -183 template │ │ │ │ │ -184 struct filter_helper │ │ │ │ │ -185 { │ │ │ │ │ -186 template │ │ │ │ │ -187 struct apply │ │ │ │ │ -188 { │ │ │ │ │ -189 typedef _F_i_l_t_e_r_R_e_s_u_l_t type; │ │ │ │ │ -190 }; │ │ │ │ │ -191 }; │ │ │ │ │ +126 │ │ │ │ │ +128 │ │ │ │ │ +_1_6_3 struct _D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ +164 { │ │ │ │ │ +165 │ │ │ │ │ +167 │ │ │ │ │ +175 template │ │ │ │ │ +_1_7_6 void _p_r_e(T1&&, T2&&, TreePath) const {} │ │ │ │ │ +177 │ │ │ │ │ +179 │ │ │ │ │ +188 template │ │ │ │ │ +_1_8_9 void _i_n(T1&&, T2&&, TreePath) const {} │ │ │ │ │ +190 │ │ │ │ │ 192 │ │ │ │ │ -193 template │ │ │ │ │ -194 struct filter_helper │ │ │ │ │ -195 { │ │ │ │ │ -196 │ │ │ │ │ -197 template │ │ │ │ │ -198 struct apply │ │ │ │ │ -199 : public std::conditional::value, │ │ │ │ │ -200 typename filter_helper::template │ │ │ │ │ -apply >, │ │ │ │ │ -201 typename filter_helper::template │ │ │ │ │ -apply │ │ │ │ │ -202 >::type │ │ │ │ │ -203 {}; │ │ │ │ │ +200 template │ │ │ │ │ +_2_0_1 void _p_o_s_t(T1&&, T2&&, TreePath) const {} │ │ │ │ │ +202 │ │ │ │ │ 204 │ │ │ │ │ -205 }; │ │ │ │ │ -206 │ │ │ │ │ -207 } // anonymous namespace │ │ │ │ │ -208 │ │ │ │ │ -210 template │ │ │ │ │ -_2_1_1 struct _f_i_l_t_e_r │ │ │ │ │ -212 { │ │ │ │ │ -213 │ │ │ │ │ -215 template │ │ │ │ │ -_2_1_6 struct _a_p_p_l_y │ │ │ │ │ -217 { │ │ │ │ │ -218 │ │ │ │ │ -219 static_assert((Filter::template validate::value),"Invalid simple │ │ │ │ │ -filter"); │ │ │ │ │ -220 │ │ │ │ │ -_2_2_1 typedef typename filter_helper::template _a_p_p_l_y_<_>_:_: │ │ │ │ │ -_t_y_p_e _t_y_p_e; │ │ │ │ │ -222 │ │ │ │ │ -223 }; │ │ │ │ │ -224 │ │ │ │ │ -225 }; │ │ │ │ │ -226 │ │ │ │ │ -228 │ │ │ │ │ -229 } // namespace TypeTree │ │ │ │ │ -230} //namespace Dune │ │ │ │ │ -231 │ │ │ │ │ -232#endif // DUNE_TYPETREE_FILTERS_HH │ │ │ │ │ -_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 │ │ │ │ │ +215 template │ │ │ │ │ +_2_1_6 void _l_e_a_f(T1&&, T2&&, TreePath) const {} │ │ │ │ │ +217 │ │ │ │ │ +219 │ │ │ │ │ +231 template │ │ │ │ │ +_2_3_2 void _b_e_f_o_r_e_C_h_i_l_d(T1&&, Child1&&, T2&&, Child2&&, TreePath, ChildIndex) │ │ │ │ │ +const {} │ │ │ │ │ +233 │ │ │ │ │ +235 │ │ │ │ │ +247 template │ │ │ │ │ +_2_4_8 void _a_f_t_e_r_C_h_i_l_d(T1&&, Child1&&, T2&&, Child2&&, TreePath, ChildIndex) const │ │ │ │ │ +{} │ │ │ │ │ +249 │ │ │ │ │ +250 }; │ │ │ │ │ +251 │ │ │ │ │ +252 │ │ │ │ │ +253 namespace Experimental { │ │ │ │ │ +254 │ │ │ │ │ +_2_8_5 struct _D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r │ │ │ │ │ +286 { │ │ │ │ │ +287 │ │ │ │ │ +295 template │ │ │ │ │ +_2_9_6 auto _p_r_e(T&&, TreePath, const U& u) const { return u;} │ │ │ │ │ +297 │ │ │ │ │ +305 template │ │ │ │ │ +_3_0_6 auto _i_n(T&&, TreePath, const U& u) const {return u;} │ │ │ │ │ +307 │ │ │ │ │ +315 template │ │ │ │ │ +_3_1_6 auto _p_o_s_t(T&&, TreePath, const U& u) const {return u;} │ │ │ │ │ +317 │ │ │ │ │ +325 template │ │ │ │ │ +_3_2_6 auto _l_e_a_f(T&&, TreePath, const U& u) const { return u;} │ │ │ │ │ +327 │ │ │ │ │ +335 template │ │ │ │ │ +_3_3_6 auto _b_e_f_o_r_e_C_h_i_l_d(T&&, _C_h_i_l_d&&, TreePath, ChildIndex, const U& u) const │ │ │ │ │ +{return u;} │ │ │ │ │ +337 │ │ │ │ │ +345 template │ │ │ │ │ +_3_4_6 auto _a_f_t_e_r_C_h_i_l_d(T&&, _C_h_i_l_d&&, TreePath, ChildIndex, const U& u) const │ │ │ │ │ +{return u;} │ │ │ │ │ +347 │ │ │ │ │ +348 }; │ │ │ │ │ +349 } // namespace Experimental │ │ │ │ │ +350 │ │ │ │ │ +352 │ │ │ │ │ +_3_5_7 struct _V_i_s_i_t_D_i_r_e_c_t_C_h_i_l_d_r_e_n │ │ │ │ │ +358 { │ │ │ │ │ +359 │ │ │ │ │ +360 // the little trick with the default template arguments │ │ │ │ │ +361 // makes the class usable for both single-tree visitors │ │ │ │ │ +362 // and visitors for pairs of trees │ │ │ │ │ +364 template │ │ │ │ │ +_3_6_9 struct _V_i_s_i_t_C_h_i_l_d │ │ │ │ │ +370 { │ │ │ │ │ +_3_7_2 static const bool _v_a_l_u_e = false; │ │ │ │ │ +373 }; │ │ │ │ │ +374 │ │ │ │ │ +375 }; │ │ │ │ │ +376 │ │ │ │ │ +377 │ │ │ │ │ +379 │ │ │ │ │ +_3_8_3 struct _V_i_s_i_t_T_r_e_e │ │ │ │ │ +384 { │ │ │ │ │ +385 │ │ │ │ │ +386 // the little trick with the default template arguments │ │ │ │ │ +387 // makes the class usable for both single-tree visitors │ │ │ │ │ +388 // and visitors for pairs of trees │ │ │ │ │ +390 template │ │ │ │ │ +_3_9_5 struct _V_i_s_i_t_C_h_i_l_d │ │ │ │ │ +396 { │ │ │ │ │ +_3_9_8 static const bool _v_a_l_u_e = true; │ │ │ │ │ +399 }; │ │ │ │ │ +400 │ │ │ │ │ +401 }; │ │ │ │ │ +402 │ │ │ │ │ +404 │ │ │ │ │ +_4_1_1 struct _S_t_a_t_i_c_T_r_a_v_e_r_s_a_l │ │ │ │ │ +412 { │ │ │ │ │ +_4_1_4 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_:_:_f_u_l_l_y_S_t_a_t_i_c; │ │ │ │ │ +415 }; │ │ │ │ │ +416 │ │ │ │ │ +418 │ │ │ │ │ +_4_2_5 struct _D_y_n_a_m_i_c_T_r_a_v_e_r_s_a_l │ │ │ │ │ +426 { │ │ │ │ │ +_4_2_8 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; │ │ │ │ │ +429 }; │ │ │ │ │ +430 │ │ │ │ │ +_4_3_2 struct _T_r_e_e_V_i_s_i_t_o_r │ │ │ │ │ +433 : public _D_e_f_a_u_l_t_V_i_s_i_t_o_r │ │ │ │ │ +434 , public _V_i_s_i_t_T_r_e_e │ │ │ │ │ +435 {}; │ │ │ │ │ +436 │ │ │ │ │ +_4_3_8 struct _D_i_r_e_c_t_C_h_i_l_d_r_e_n_V_i_s_i_t_o_r │ │ │ │ │ +439 : public _D_e_f_a_u_l_t_V_i_s_i_t_o_r │ │ │ │ │ +440 , public _V_i_s_i_t_D_i_r_e_c_t_C_h_i_l_d_r_e_n │ │ │ │ │ +441 {}; │ │ │ │ │ +442 │ │ │ │ │ +_4_4_4 struct _T_r_e_e_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ +445 : public _D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ +446 , public _V_i_s_i_t_T_r_e_e │ │ │ │ │ +447 {}; │ │ │ │ │ +448 │ │ │ │ │ +_4_5_0 struct _D_i_r_e_c_t_C_h_i_l_d_r_e_n_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ +451 : public _D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ +452 , public _V_i_s_i_t_D_i_r_e_c_t_C_h_i_l_d_r_e_n │ │ │ │ │ +453 {}; │ │ │ │ │ +454 │ │ │ │ │ +_4_5_5 namespace Experimental::Info { │ │ │ │ │ +456 │ │ │ │ │ +_4_5_7 struct _L_e_a_f_C_o_u_n_t_e_r_V_i_s_i_t_o_r │ │ │ │ │ +458 : public _D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r │ │ │ │ │ +459 , public _S_t_a_t_i_c_T_r_a_v_e_r_s_a_l │ │ │ │ │ +460 , public _V_i_s_i_t_T_r_e_e │ │ │ │ │ +461 { │ │ │ │ │ +462 template │ │ │ │ │ +_4_6_3 auto _b_e_f_o_r_e_C_h_i_l_d(Tree&&, _C_h_i_l_d&&, TreePath, ChildIndex, U u) const { │ │ │ │ │ +464 // in this case child index is an integral constant: forward u │ │ │ │ │ +465 return u; │ │ │ │ │ +466 } │ │ │ │ │ +467 │ │ │ │ │ +468 template │ │ │ │ │ +_4_6_9 std::size_t _b_e_f_o_r_e_C_h_i_l_d(Tree&&, _C_h_i_l_d&&, TreePath, std::size_t / │ │ │ │ │ +*childIndex*/, U u) const { │ │ │ │ │ +470 // in this case child index is a run-time index: cast accumulated u to │ │ │ │ │ +std::size_t │ │ │ │ │ +471 return std::size_t{u}; │ │ │ │ │ +472 } │ │ │ │ │ +473 │ │ │ │ │ +474 template │ │ │ │ │ +_4_7_5 auto _l_e_a_f(Tree&&, TreePath, U u) const │ │ │ │ │ +476 { │ │ │ │ │ +477 return Hybrid::plus(u,Dune::Indices::_1); │ │ │ │ │ +478 } │ │ │ │ │ +479 │ │ │ │ │ +480 }; │ │ │ │ │ +481 │ │ │ │ │ +_4_8_2 struct _N_o_d_e_C_o_u_n_t_e_r_V_i_s_i_t_o_r │ │ │ │ │ +483 : public _L_e_a_f_C_o_u_n_t_e_r_V_i_s_i_t_o_r │ │ │ │ │ +484 { │ │ │ │ │ +485 template │ │ │ │ │ +_4_8_6 auto _p_r_e(Tree&&, TreePath, U u) const { │ │ │ │ │ +487 return Hybrid::plus(u,Indices::_1); │ │ │ │ │ +488 } │ │ │ │ │ +489 }; │ │ │ │ │ +490 │ │ │ │ │ +_4_9_1 struct _D_e_p_t_h_V_i_s_i_t_o_r │ │ │ │ │ +492 : public _D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r │ │ │ │ │ +493 , public _S_t_a_t_i_c_T_r_a_v_e_r_s_a_l │ │ │ │ │ +494 , public _V_i_s_i_t_T_r_e_e │ │ │ │ │ +495 { │ │ │ │ │ +496 template │ │ │ │ │ +_4_9_7 auto _l_e_a_f(Tree&&, TreePath, U u) const │ │ │ │ │ +498 { │ │ │ │ │ +499 auto path_size = index_constant<_t_r_e_e_P_a_t_h_S_i_z_e(TreePath{})>{}; │ │ │ │ │ +500 auto _d_e_p_t_h = Hybrid::plus(path_size,Indices::_1); │ │ │ │ │ +501 return Hybrid::max(_d_e_p_t_h,u); │ │ │ │ │ +502 } │ │ │ │ │ +503 }; │ │ │ │ │ +504 │ │ │ │ │ +506 // result is alwayas an integral constant │ │ │ │ │ +507 template │ │ │ │ │ +_5_0_8 auto _d_e_p_t_h(const Tree& tree) │ │ │ │ │ +509 { │ │ │ │ │ +510 return _h_y_b_r_i_d_A_p_p_l_y_T_o_T_r_e_e(tree,_D_e_p_t_h_V_i_s_i_t_o_r{},Indices::_0); │ │ │ │ │ +511 } │ │ │ │ │ +512 │ │ │ │ │ +514 // return types is std::integral_constant. │ │ │ │ │ +515 template │ │ │ │ │ +_5_1_6 constexpr auto _d_e_p_t_h() │ │ │ │ │ +517 { │ │ │ │ │ +518 return decltype(_h_y_b_r_i_d_A_p_p_l_y_T_o_T_r_e_e(std::declval(),_D_e_p_t_h_V_i_s_i_t_o_r │ │ │ │ │ +{},Indices::_0)){}; │ │ │ │ │ +519 } │ │ │ │ │ +520 │ │ │ │ │ +522 // if Tree is dynamic, return type is std::size_t, otherwise std:: │ │ │ │ │ +integral_constant. │ │ │ │ │ +523 template │ │ │ │ │ +_5_2_4 auto _n_o_d_e_C_o_u_n_t(const Tree& tree) │ │ │ │ │ +525 { │ │ │ │ │ +526 return _h_y_b_r_i_d_A_p_p_l_y_T_o_T_r_e_e(tree,_N_o_d_e_C_o_u_n_t_e_r_V_i_s_i_t_o_r{},Indices::_0); │ │ │ │ │ +527 } │ │ │ │ │ +528 │ │ │ │ │ +530 // if Tree is dynamic, return type is std::size_t, otherwise std:: │ │ │ │ │ +integral_constant. │ │ │ │ │ +531 template │ │ │ │ │ +_5_3_2 auto _l_e_a_f_C_o_u_n_t(const Tree& tree) │ │ │ │ │ +533 { │ │ │ │ │ +534 return _h_y_b_r_i_d_A_p_p_l_y_T_o_T_r_e_e(tree,_L_e_a_f_C_o_u_n_t_e_r_V_i_s_i_t_o_r{},Dune::Indices::_0); │ │ │ │ │ +535 } │ │ │ │ │ +536 │ │ │ │ │ +538 template │ │ │ │ │ +_5_3_9 constexpr bool _i_s_D_y_n_a_m_i_c = std::is_same()))>{}; │ │ │ │ │ +540 │ │ │ │ │ +541 } // namespace Experimental::Info │ │ │ │ │ +542 │ │ │ │ │ +544 │ │ │ │ │ +545 } // namespace TypeTree │ │ │ │ │ +546} //namespace Dune │ │ │ │ │ +547 │ │ │ │ │ +548#endif // DUNE_TYPETREE_VISITOR_HH │ │ │ │ │ +_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_:_:_t_r_e_e_P_a_t_h_S_i_z_e │ │ │ │ │ +constexpr std::size_t treePathSize(const HybridTreePath< T... > &) │ │ │ │ │ +Returns the size (number of components) of the given HybridTreePath. │ │ │ │ │ +DDeeffiinniittiioonn treepath.hh:334 │ │ │ │ │ _D_u_n_e │ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_E_n_t_r_y │ │ │ │ │ -A filter entry describing the mapping of one child in the filtered node. │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:24 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_R_e_s_u_l_t │ │ │ │ │ -The result of a filter. │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:40 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_R_e_s_u_l_t_:_:_I_n_d_e_x_M_a_p │ │ │ │ │ -std::tuple< FilterEntries... > IndexMap │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:44 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_R_e_s_u_l_t_:_:_s_i_z_e │ │ │ │ │ -static const std::size_t size │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:42 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_R_e_s_u_l_t_:_:_a_p_p_l_y │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:48 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_R_e_s_u_l_t_:_:_a_p_p_l_y_:_:_C_h_i_l_d_r_e_n │ │ │ │ │ -std::tuple< typename Node::template Child< FilterEntries::original_index >... > │ │ │ │ │ -Children │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:49 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_R_e_s_u_l_t_:_:_a_p_p_l_y_:_:_C_h_i_l_d_T_y_p_e_s │ │ │ │ │ -std::tuple< typename Node::template Child< FilterEntries::original_index >:: │ │ │ │ │ -Type... > ChildTypes │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:50 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_R_e_s_u_l_t_:_:_a_p_p_l_y_:_:_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ -std::tuple< std::shared_ptr< typename Node::template Child< FilterEntries:: │ │ │ │ │ -original_index >::Type >... > NodeStorage │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:51 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r_T_a_g │ │ │ │ │ -Tag describing a simple filter that can only decide whether or not to include a │ │ │ │ │ -single given child. │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:57 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_d_v_a_n_c_e_d_F_i_l_t_e_r_T_a_g │ │ │ │ │ -Tag describing an advanced filter that has full control over the construction │ │ │ │ │ -of the list of FilterEn... │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:60 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_d_v_a_n_c_e_d_F_i_l_t_e_r │ │ │ │ │ -Base class for advanced filters. │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:65 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_d_v_a_n_c_e_d_F_i_l_t_e_r_:_:_F_i_l_t_e_r_T_a_g │ │ │ │ │ -AdvancedFilterTag FilterTag │ │ │ │ │ -Filter tag for deciding on filter application mechanism. │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:68 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_d_v_a_n_c_e_d_F_i_l_t_e_r_:_:_a_p_p_l_y │ │ │ │ │ -Apply this filter to the given node and children. │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:75 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_A_d_v_a_n_c_e_d_F_i_l_t_e_r_:_:_a_p_p_l_y_:_:_t_y_p_e │ │ │ │ │ -implementation defined type │ │ │ │ │ -The result of the filtering process. │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:80 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r │ │ │ │ │ -Default simple filter that accepts any node and leaves its child structure │ │ │ │ │ -unchanged. │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:94 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r_:_:_F_i_l_t_e_r_T_a_g │ │ │ │ │ -SimpleFilterTag FilterTag │ │ │ │ │ -Filter tag for deciding on filter application mechanism. │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:97 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r_:_:_v_a_l_i_d_a_t_e │ │ │ │ │ -Validates the combination of filter and node. │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:103 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r_:_:_v_a_l_i_d_a_t_e_:_:_v_a_l_u_e │ │ │ │ │ +_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 │ │ │ │ │ +auto hybridApplyToTree(Tree &&tree, Visitor &&visitor, Init &&init) │ │ │ │ │ +Apply hybrid visitor to TypeTree. │ │ │ │ │ +DDeeffiinniittiioonn accumulate_static.hh:701 │ │ │ │ │ +_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_:_:_f_u_l_l_y_S_t_a_t_i_c │ │ │ │ │ +@ fullyStatic │ │ │ │ │ +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 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_i_s_D_y_n_a_m_i_c │ │ │ │ │ +constexpr bool isDynamic │ │ │ │ │ +true if any of the nodes in the tree only has dynamic degree. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:539 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_l_e_a_f_C_o_u_n_t │ │ │ │ │ +auto leafCount(const Tree &tree) │ │ │ │ │ +The number of leaf nodes in the Tree. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:532 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_n_o_d_e_C_o_u_n_t │ │ │ │ │ +auto nodeCount(const Tree &tree) │ │ │ │ │ +The total number of nodes in the Tree. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:524 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_d_e_p_t_h │ │ │ │ │ +constexpr auto depth() │ │ │ │ │ +The depth of the Tree. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:516 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_V_i_s_i_t_o_r │ │ │ │ │ +Visitor interface and base class for TypeTree visitors. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:49 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_V_i_s_i_t_o_r_:_:_i_n │ │ │ │ │ +void in(T &&, TreePath) const │ │ │ │ │ +Method for infix tree traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:72 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_V_i_s_i_t_o_r_:_:_a_f_t_e_r_C_h_i_l_d │ │ │ │ │ +void afterChild(T &&, Child &&, TreePath, ChildIndex) const │ │ │ │ │ +Method for child-parent traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:122 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_V_i_s_i_t_o_r_:_:_b_e_f_o_r_e_C_h_i_l_d │ │ │ │ │ +void beforeChild(T &&, Child &&, TreePath, ChildIndex) const │ │ │ │ │ +Method for parent-child traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:107 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_V_i_s_i_t_o_r_:_:_p_o_s_t │ │ │ │ │ +void post(T &&, TreePath) const │ │ │ │ │ +Method for postfix tree traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:83 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_V_i_s_i_t_o_r_:_:_l_e_a_f │ │ │ │ │ +void leaf(T &&, TreePath) const │ │ │ │ │ +Method for leaf traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:93 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_V_i_s_i_t_o_r_:_:_p_r_e │ │ │ │ │ +void pre(T &&, TreePath) const │ │ │ │ │ +Method for prefix tree traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:60 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ +Visitor interface and base class for visitors of pairs of TypeTrees. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:164 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r_:_:_l_e_a_f │ │ │ │ │ +void leaf(T1 &&, T2 &&, TreePath) const │ │ │ │ │ +Method for leaf traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:216 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r_:_:_b_e_f_o_r_e_C_h_i_l_d │ │ │ │ │ +void beforeChild(T1 &&, Child1 &&, T2 &&, Child2 &&, TreePath, ChildIndex) │ │ │ │ │ +const │ │ │ │ │ +Method for parent-child traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:232 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r_:_:_p_r_e │ │ │ │ │ +void pre(T1 &&, T2 &&, TreePath) const │ │ │ │ │ +Method for prefix tree traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:176 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r_:_:_p_o_s_t │ │ │ │ │ +void post(T1 &&, T2 &&, TreePath) const │ │ │ │ │ +Method for postfix traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:201 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r_:_:_i_n │ │ │ │ │ +void in(T1 &&, T2 &&, TreePath) const │ │ │ │ │ +Method for infix tree traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:189 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_f_a_u_l_t_P_a_i_r_V_i_s_i_t_o_r_:_:_a_f_t_e_r_C_h_i_l_d │ │ │ │ │ +void afterChild(T1 &&, Child1 &&, T2 &&, Child2 &&, TreePath, ChildIndex) const │ │ │ │ │ +Method for child-parent traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:248 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r │ │ │ │ │ +Hybrid visitor interface and base class for TypeTree hybrid visitors. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:286 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r_:_:_p_o_s_t │ │ │ │ │ +auto post(T &&, TreePath, const U &u) const │ │ │ │ │ +Method for postfix tree traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:316 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r_:_:_p_r_e │ │ │ │ │ +auto pre(T &&, TreePath, const U &u) const │ │ │ │ │ +Method for prefix tree traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:296 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r_:_:_l_e_a_f │ │ │ │ │ +auto leaf(T &&, TreePath, const U &u) const │ │ │ │ │ +Method for leaf traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:326 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r_:_:_a_f_t_e_r_C_h_i_l_d │ │ │ │ │ +auto afterChild(T &&, Child &&, TreePath, ChildIndex, const U &u) const │ │ │ │ │ +Method for child-parent traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:346 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r_:_:_i_n │ │ │ │ │ +auto in(T &&, TreePath, const U &u) const │ │ │ │ │ +Method for infix tree traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:306 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_D_e_f_a_u_l_t_H_y_b_r_i_d_V_i_s_i_t_o_r_:_:_b_e_f_o_r_e_C_h_i_l_d │ │ │ │ │ +auto beforeChild(T &&, Child &&, TreePath, ChildIndex, const U &u) const │ │ │ │ │ +Method for parent-child traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:336 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_D_i_r_e_c_t_C_h_i_l_d_r_e_n │ │ │ │ │ +Mixin base class for visitors that only want to visit the direct children of a │ │ │ │ │ +node. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:358 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_D_i_r_e_c_t_C_h_i_l_d_r_e_n_:_:_V_i_s_i_t_C_h_i_l_d │ │ │ │ │ +Template struct for determining whether or not to visit a given child. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:370 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_D_i_r_e_c_t_C_h_i_l_d_r_e_n_:_:_V_i_s_i_t_C_h_i_l_d_:_:_v_a_l_u_e │ │ │ │ │ static const bool value │ │ │ │ │ -True if the combination of filter and node is valid. │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:105 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r_:_:_a_p_p_l_y │ │ │ │ │ -Applies the filter to the given child node. │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:119 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_i_m_p_l_e_F_i_l_t_e_r_:_:_a_p_p_l_y_:_:_v_a_l_u_e │ │ │ │ │ +Do not visit any child. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:372 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_T_r_e_e │ │ │ │ │ +Mixin base class for visitors that want to visit the complete tree. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:384 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_T_r_e_e_:_:_V_i_s_i_t_C_h_i_l_d │ │ │ │ │ +Template struct for determining whether or not to visit a given child. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:396 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_V_i_s_i_t_T_r_e_e_:_:_V_i_s_i_t_C_h_i_l_d_:_:_v_a_l_u_e │ │ │ │ │ static const bool value │ │ │ │ │ -True if the child will be included in the filtered node. │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:121 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_I_n_d_e_x_F_i_l_t_e_r │ │ │ │ │ -Filter class for FilteredCompositeNode that selects the children with the given │ │ │ │ │ -indices. │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:161 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_i_l_t_e_r │ │ │ │ │ -Adapter class that takes a SimpleFilter, validated it and turns it into an │ │ │ │ │ -AdvancedFilter. │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:212 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_i_l_t_e_r_:_:_a_p_p_l_y │ │ │ │ │ -Apply the filter. │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:217 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_i_l_t_e_r_:_:_a_p_p_l_y_:_:_t_y_p_e │ │ │ │ │ -filter_helper< Filter, 0, 0, Children... >::template apply ::type type │ │ │ │ │ -DDeeffiinniittiioonn filters.hh:221 │ │ │ │ │ +Visit any child. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:398 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_T_r_a_v_e_r_s_a_l │ │ │ │ │ +Mixin base class for visitors that require a static TreePath during traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:412 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_T_r_a_v_e_r_s_a_l_:_:_t_r_e_e_P_a_t_h_T_y_p_e │ │ │ │ │ +static const TreePathType::Type treePathType │ │ │ │ │ +Use the static tree traversal algorithm. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:414 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_T_r_a_v_e_r_s_a_l │ │ │ │ │ +Mixin base class for visitors that only need a dynamic TreePath during │ │ │ │ │ +traversal. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:426 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_T_r_a_v_e_r_s_a_l_:_:_t_r_e_e_P_a_t_h_T_y_p_e │ │ │ │ │ +static const TreePathType::Type treePathType │ │ │ │ │ +Use the dynamic tree traversal algorithm. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:428 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_V_i_s_i_t_o_r │ │ │ │ │ +Convenience base class for visiting the entire tree. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:435 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_i_r_e_c_t_C_h_i_l_d_r_e_n_V_i_s_i_t_o_r │ │ │ │ │ +Convenience base class for visiting the direct children of a node. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:441 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_e_e_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ +Convenience base class for visiting an entire tree pair. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:447 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_i_r_e_c_t_C_h_i_l_d_r_e_n_P_a_i_r_V_i_s_i_t_o_r │ │ │ │ │ +Convenience base class for visiting the direct children of a node pair. │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:453 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_L_e_a_f_C_o_u_n_t_e_r_V_i_s_i_t_o_r │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:461 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_L_e_a_f_C_o_u_n_t_e_r_V_i_s_i_t_o_r_:_:_l_e_a_f │ │ │ │ │ +auto leaf(Tree &&, TreePath, U u) const │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:475 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_L_e_a_f_C_o_u_n_t_e_r_V_i_s_i_t_o_r_:_:_b_e_f_o_r_e_C_h_i_l_d │ │ │ │ │ +auto beforeChild(Tree &&, Child &&, TreePath, ChildIndex, U u) const │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:463 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_L_e_a_f_C_o_u_n_t_e_r_V_i_s_i_t_o_r_:_:_b_e_f_o_r_e_C_h_i_l_d │ │ │ │ │ +std::size_t beforeChild(Tree &&, Child &&, TreePath, std::size_t, U u) const │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:469 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_N_o_d_e_C_o_u_n_t_e_r_V_i_s_i_t_o_r │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:484 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_N_o_d_e_C_o_u_n_t_e_r_V_i_s_i_t_o_r_:_:_p_r_e │ │ │ │ │ +auto pre(Tree &&, TreePath, U u) const │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:486 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_D_e_p_t_h_V_i_s_i_t_o_r │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:495 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_p_e_r_i_m_e_n_t_a_l_:_:_I_n_f_o_:_:_D_e_p_t_h_V_i_s_i_t_o_r_:_:_l_e_a_f │ │ │ │ │ +auto leaf(Tree &&, TreePath, U u) const │ │ │ │ │ +DDeeffiinniittiioonn visitor.hh:497 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00077.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: dynamicpowernode.hh File Reference │ │ │ │ +dune-typetree: transformation.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -71,42 +71,52 @@ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ Classes | │ │ │ │ -Namespaces
    │ │ │ │ -
    dynamicpowernode.hh File Reference
    │ │ │ │ +Namespaces | │ │ │ │ +Functions
    │ │ │ │ +
    transformation.hh File Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ -
    #include <cassert>
    │ │ │ │ -#include <vector>
    │ │ │ │ +
    #include <array>
    │ │ │ │ +#include <tuple>
    │ │ │ │ #include <memory>
    │ │ │ │ -#include <type_traits>
    │ │ │ │ +#include <utility>
    │ │ │ │ +#include <dune/common/hybridutilities.hh>
    │ │ │ │ +#include <dune/common/exceptions.hh>
    │ │ │ │ #include <dune/common/typetraits.hh>
    │ │ │ │ -#include <dune/common/std/type_traits.hh>
    │ │ │ │ -#include <dune/typetree/nodetags.hh>
    │ │ │ │ -#include <dune/typetree/utility.hh>
    │ │ │ │ -#include <dune/typetree/typetraits.hh>
    │ │ │ │ +#include <dune/typetree/typetraits.hh>
    │ │ │ │ +#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ +#include <dune/typetree/nodetags.hh>
    │ │ │ │ +#include <dune/typetree/utility.hh>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    class  Dune::TypeTree::DynamicPowerNode< T >
     Collect multiple instances of type T within a dune-typetree. More...
    struct  Dune::TypeTree::TransformTree< SourceTree, Transformation, Tag, recursive >
     Transform a TypeTree. More...
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ +

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
     
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │

    │ │ │ │ +Functions

    template<typename SourceNode , typename Transformation , typename Tag >
    void Dune::TypeTree::registerNodeTransformation (SourceNode *, Transformation *, Tag *)
     Register transformation descriptor to transform SourceNode with Transformation.
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,29 +1,39 @@ │ │ │ │ │ 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 │ │ │ │ │ -dynamicpowernode.hh File Reference │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ +_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 │ │ │ │ │ +transformation.hh File Reference │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ #include │ │ │ │ │ -#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ #include │ │ │ │ │ -#include │ │ │ │ │ +#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_y_p_e_t_r_a_i_t_s_._h_h> │ │ │ │ │ +#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_/_u_t_i_l_i_t_y_._h_h> │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_y_p_e_t_r_a_i_t_s_._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 │ │ │ │ │ -class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_<_ _T_ _> │ │ │ │ │ -  Collect multiple instances of type T within a _d_u_n_e_-_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_r_a_n_s_f_o_r_m_T_r_e_e_<_ _S_o_u_r_c_e_T_r_e_e_,_ _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_a_g_, │ │ │ │ │ + _r_e_c_u_r_s_i_v_e_ _> │ │ │ │ │ +  Transform 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 │ │ │ │ │   │ │ │ │ │ +FFuunnccttiioonnss │ │ │ │ │ +template │ │ │ │ │ +void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_r_e_g_i_s_t_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n (SourceNode *, Transformation │ │ │ │ │ + *, Tag *) │ │ │ │ │ +  Register transformation descriptor to transform SourceNode with │ │ │ │ │ + Transformation. │ │ │ │ │ +  │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00077_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: dynamicpowernode.hh Source File │ │ │ │ +dune-typetree: transformation.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,221 +74,512 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -
    dynamicpowernode.hh
    │ │ │ │ +
    transformation.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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_DYNAMICPOWERNODE_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_DYNAMICPOWERNODE_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_TRANSFORMATION_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_TRANSFORMATION_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <cassert>
    │ │ │ │ -
    10#include <vector>
    │ │ │ │ +
    9#include <array>
    │ │ │ │ +
    10#include <tuple>
    │ │ │ │
    11#include <memory>
    │ │ │ │ -
    12#include <type_traits>
    │ │ │ │ +
    12#include <utility>
    │ │ │ │
    13
    │ │ │ │ -
    14#include <dune/common/typetraits.hh>
    │ │ │ │ -
    15#include <dune/common/std/type_traits.hh>
    │ │ │ │ -
    16
    │ │ │ │ -
    17#include <dune/typetree/nodetags.hh>
    │ │ │ │ -
    18#include <dune/typetree/utility.hh>
    │ │ │ │ -
    19#include <dune/typetree/typetraits.hh>
    │ │ │ │ -
    20
    │ │ │ │ -
    21namespace Dune {
    │ │ │ │ -
    22 namespace TypeTree {
    │ │ │ │ -
    23
    │ │ │ │ -
    33 template<typename T>
    │ │ │ │ -
    │ │ │ │ -
    34 class DynamicPowerNode
    │ │ │ │ -
    35 {
    │ │ │ │ -
    36
    │ │ │ │ -
    37 public:
    │ │ │ │ -
    38
    │ │ │ │ -
    40 static const bool isLeaf = false;
    │ │ │ │ -
    41
    │ │ │ │ -
    43 static const bool isPower = true;
    │ │ │ │ -
    44
    │ │ │ │ -
    46 static const bool isComposite = false;
    │ │ │ │ -
    47
    │ │ │ │ -
    │ │ │ │ -
    49 std::size_t degree() const
    │ │ │ │ -
    50 {
    │ │ │ │ -
    51 return _children.size();
    │ │ │ │ -
    52 }
    │ │ │ │ -
    │ │ │ │ -
    53
    │ │ │ │ -
    55 typedef DynamicPowerNodeTag NodeTag;
    │ │ │ │ -
    56
    │ │ │ │ -
    58 typedef T ChildType;
    │ │ │ │ -
    59
    │ │ │ │ -
    61 typedef std::shared_ptr<T> ChildStorageType;
    │ │ │ │ -
    62
    │ │ │ │ -
    64 typedef std::shared_ptr<const T> ChildConstStorageType;
    │ │ │ │ -
    65
    │ │ │ │ -
    67 typedef std::vector<ChildStorageType> NodeStorage;
    │ │ │ │ -
    68
    │ │ │ │ -
    69
    │ │ │ │ -
    72
    │ │ │ │ -
    74
    │ │ │ │ -
    │ │ │ │ -
    77 ChildType& child (std::size_t i)
    │ │ │ │ -
    78 {
    │ │ │ │ -
    79 assert(i < degree() && "child index out of range");
    │ │ │ │ -
    80 return *_children[i];
    │ │ │ │ -
    81 }
    │ │ │ │ -
    │ │ │ │ +
    14#include <dune/common/hybridutilities.hh>
    │ │ │ │ +
    15#include <dune/common/exceptions.hh>
    │ │ │ │ +
    16#include <dune/common/typetraits.hh>
    │ │ │ │ +
    17#include <dune/typetree/typetraits.hh>
    │ │ │ │ +
    18#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ +
    19#include <dune/typetree/nodetags.hh>
    │ │ │ │ +
    20#include <dune/typetree/utility.hh>
    │ │ │ │ +
    21
    │ │ │ │ +
    22
    │ │ │ │ +
    23namespace Dune {
    │ │ │ │ +
    24 namespace TypeTree {
    │ │ │ │ +
    25
    │ │ │ │ +
    31#ifdef DOXYGEN
    │ │ │ │ +
    32
    │ │ │ │ +
    34
    │ │ │ │ +
    53 template<typename SourceNode, typename Transformation, typename Tag>
    │ │ │ │ +
    54 void registerNodeTransformation(SourceNode*, Transformation*, Tag*);
    │ │ │ │ +
    55
    │ │ │ │ +
    56#else // DOXYGEN
    │ │ │ │ +
    57
    │ │ │ │ +
    68 template<typename S, typename T, typename Tag>
    │ │ │ │ +
    69 struct LookupNodeTransformation
    │ │ │ │ +
    70 {
    │ │ │ │ +
    71
    │ │ │ │ +
    72 typedef decltype(registerNodeTransformation(declptr<S>(),declptr<T>(),declptr<Tag>())) lookup_type;
    │ │ │ │ +
    73
    │ │ │ │ +
    74 typedef typename evaluate_if_meta_function<
    │ │ │ │ +
    75 lookup_type
    │ │ │ │ +
    76 >::type type;
    │ │ │ │ +
    77
    │ │ │ │ +
    78 static_assert((!std::is_same<type,void>::value), "Unable to find valid transformation descriptor");
    │ │ │ │ +
    79 };
    │ │ │ │ +
    80
    │ │ │ │ +
    81#endif // DOXYGEN
    │ │ │ │
    82
    │ │ │ │ -
    84
    │ │ │ │ -
    │ │ │ │ -
    87 const ChildType& child (std::size_t i) const
    │ │ │ │ -
    88 {
    │ │ │ │ -
    89 assert(i < degree() && "child index out of range");
    │ │ │ │ -
    90 return *_children[i];
    │ │ │ │ -
    91 }
    │ │ │ │ -
    │ │ │ │ -
    92
    │ │ │ │ -
    94
    │ │ │ │ -
    │ │ │ │ -
    97 ChildStorageType childStorage (std::size_t i)
    │ │ │ │ -
    98 {
    │ │ │ │ -
    99 assert(i < degree() && "child index out of range");
    │ │ │ │ -
    100 return _children[i];
    │ │ │ │ -
    101 }
    │ │ │ │ -
    │ │ │ │ -
    102
    │ │ │ │ +
    83
    │ │ │ │ +
    85
    │ │ │ │ +
    94 template<typename SourceTree, typename Transformation, typename Tag = StartTag, bool recursive = true>
    │ │ │ │ +
    │ │ │ │ +
    95 struct TransformTree
    │ │ │ │ +
    96 {
    │ │ │ │ +
    97
    │ │ │ │ +
    98#ifndef DOXYGEN
    │ │ │ │ +
    99
    │ │ │ │ +
    100 typedef typename LookupNodeTransformation<SourceTree,Transformation,typename SourceTree::ImplementationTag>::type NodeTransformation;
    │ │ │ │ +
    101
    │ │ │ │ +
    102 // the type of the new tree that will result from this transformation
    │ │ │ │ +
    103 typedef typename TransformTree<SourceTree,Transformation,NodeTag<SourceTree>,NodeTransformation::recursive>::transformed_type transformed_type;
    │ │ │ │
    104
    │ │ │ │ -
    │ │ │ │ -
    110 ChildConstStorageType childStorage (std::size_t i) const
    │ │ │ │ -
    111 {
    │ │ │ │ -
    112 assert(i < degree() && "child index out of range");
    │ │ │ │ -
    113 return _children[i];
    │ │ │ │ -
    114 }
    │ │ │ │ -
    │ │ │ │ -
    115
    │ │ │ │ -
    │ │ │ │ -
    117 void setChild (std::size_t i, ChildType& t)
    │ │ │ │ -
    118 {
    │ │ │ │ -
    119 assert(i < degree() && "child index out of range");
    │ │ │ │ -
    120 _children[i] = stackobject_to_shared_ptr(t);
    │ │ │ │ -
    121 }
    │ │ │ │ -
    │ │ │ │ -
    122
    │ │ │ │ -
    │ │ │ │ -
    124 void setChild (std::size_t i, ChildType&& t)
    │ │ │ │ -
    125 {
    │ │ │ │ -
    126 assert(i < degree() && "child index out of range");
    │ │ │ │ -
    127 _children[i] = convert_arg(std::move(t));
    │ │ │ │ -
    128 }
    │ │ │ │ -
    │ │ │ │ -
    129
    │ │ │ │ -
    │ │ │ │ -
    131 void setChild (std::size_t i, ChildStorageType st)
    │ │ │ │ -
    132 {
    │ │ │ │ -
    133 assert(i < degree() && "child index out of range");
    │ │ │ │ -
    134 _children[i] = std::move(st);
    │ │ │ │ -
    135 }
    │ │ │ │ -
    │ │ │ │ -
    136
    │ │ │ │ -
    │ │ │ │ -
    137 const NodeStorage& nodeStorage () const
    │ │ │ │ -
    138 {
    │ │ │ │ -
    139 return _children;
    │ │ │ │ -
    140 }
    │ │ │ │ -
    │ │ │ │ -
    141
    │ │ │ │ -
    143
    │ │ │ │ -
    146
    │ │ │ │ -
    147 protected:
    │ │ │ │ -
    148
    │ │ │ │ -
    151 DynamicPowerNode () = delete;
    │ │ │ │ +
    105 // the storage type of the new tree that will result from this transformation
    │ │ │ │ +
    106 typedef typename TransformTree<SourceTree,Transformation,NodeTag<SourceTree>,NodeTransformation::recursive>::transformed_storage_type transformed_storage_type;
    │ │ │ │ +
    107
    │ │ │ │ +
    108#endif // DOXYGEN
    │ │ │ │ +
    109
    │ │ │ │ +
    111 typedef transformed_type type;
    │ │ │ │ +
    112
    │ │ │ │ +
    113 typedef type Type;
    │ │ │ │ +
    114
    │ │ │ │ +
    │ │ │ │ +
    116 static transformed_type transform(const SourceTree& s, const Transformation& t = Transformation())
    │ │ │ │ +
    117 {
    │ │ │ │ +
    118 return TransformTree<SourceTree,Transformation,NodeTag<SourceTree>,NodeTransformation::recursive>::transform(s,t);
    │ │ │ │ +
    119 }
    │ │ │ │ +
    │ │ │ │ +
    120
    │ │ │ │ +
    │ │ │ │ +
    122 static transformed_type transform(const SourceTree& s, Transformation& t)
    │ │ │ │ +
    123 {
    │ │ │ │ +
    124 return TransformTree<SourceTree,Transformation,NodeTag<SourceTree>,NodeTransformation::recursive>::transform(s,t);
    │ │ │ │ +
    125 }
    │ │ │ │ +
    │ │ │ │ +
    126
    │ │ │ │ +
    │ │ │ │ +
    128 static transformed_type transform(std::shared_ptr<const SourceTree> sp, const Transformation& t = Transformation())
    │ │ │ │ +
    129 {
    │ │ │ │ +
    130 return TransformTree<SourceTree,Transformation,NodeTag<SourceTree>,NodeTransformation::recursive>::transform(sp,t);
    │ │ │ │ +
    131 }
    │ │ │ │ +
    │ │ │ │ +
    132
    │ │ │ │ +
    │ │ │ │ +
    134 static transformed_type transform(std::shared_ptr<const SourceTree> sp, Transformation& t)
    │ │ │ │ +
    135 {
    │ │ │ │ +
    136 return TransformTree<SourceTree,Transformation,NodeTag<SourceTree>,NodeTransformation::recursive>::transform(sp,t);
    │ │ │ │ +
    137 }
    │ │ │ │ +
    │ │ │ │ +
    138
    │ │ │ │ +
    │ │ │ │ +
    141 static transformed_storage_type transform_storage(std::shared_ptr<const SourceTree> sp, const Transformation& t = Transformation())
    │ │ │ │ +
    142 {
    │ │ │ │ +
    143 return TransformTree<SourceTree,Transformation,NodeTag<SourceTree>,NodeTransformation::recursive>::transform_storage(sp,t);
    │ │ │ │ +
    144 }
    │ │ │ │ +
    │ │ │ │ +
    145
    │ │ │ │ +
    │ │ │ │ +
    148 static transformed_storage_type transform_storage(std::shared_ptr<const SourceTree> sp, Transformation& t)
    │ │ │ │ +
    149 {
    │ │ │ │ +
    150 return TransformTree<SourceTree,Transformation,NodeTag<SourceTree>,NodeTransformation::recursive>::transform_storage(sp,t);
    │ │ │ │ +
    151 }
    │ │ │ │ +
    │ │ │ │
    152
    │ │ │ │ -
    154
    │ │ │ │ -
    │ │ │ │ -
    162 explicit DynamicPowerNode (std::size_t size)
    │ │ │ │ -
    163 : _children(size)
    │ │ │ │ -
    164 {}
    │ │ │ │ -
    │ │ │ │ -
    165
    │ │ │ │ -
    │ │ │ │ -
    167 explicit DynamicPowerNode (NodeStorage children)
    │ │ │ │ -
    168 : _children(std::move(children))
    │ │ │ │ -
    169 {}
    │ │ │ │ -
    │ │ │ │ -
    170
    │ │ │ │ -
    171#ifdef DOXYGEN
    │ │ │ │ -
    172
    │ │ │ │ -
    │ │ │ │ -
    174 DynamicPowerNode (T& t1, T& t2, ...)
    │ │ │ │ -
    175 {}
    │ │ │ │ -
    │ │ │ │ -
    176
    │ │ │ │ -
    177#else
    │ │ │ │ -
    178
    │ │ │ │ -
    179 template<typename... Children,
    │ │ │ │ -
    180 std::enable_if_t<(std::is_same_v<ChildType, std::decay_t<Children>> &&...), bool> = true>
    │ │ │ │ -
    181 DynamicPowerNode (Children&&... children)
    │ │ │ │ +
    153
    │ │ │ │ +
    154 };
    │ │ │ │ +
    │ │ │ │ +
    155
    │ │ │ │ +
    156#ifndef DOXYGEN // internal per-node implementations of the transformation algorithm
    │ │ │ │ +
    157
    │ │ │ │ +
    158 // handle a leaf node - this is easy
    │ │ │ │ +
    159 template<typename S, typename T, bool recursive>
    │ │ │ │ +
    160 struct TransformTree<S,T,LeafNodeTag,recursive>
    │ │ │ │ +
    161 {
    │ │ │ │ +
    162 // get transformed type from specification
    │ │ │ │ +
    163 typedef typename LookupNodeTransformation<S,T,ImplementationTag<S>>::type NodeTransformation;
    │ │ │ │ +
    164
    │ │ │ │ +
    165 typedef typename NodeTransformation::transformed_type transformed_type;
    │ │ │ │ +
    166 typedef typename NodeTransformation::transformed_storage_type transformed_storage_type;
    │ │ │ │ +
    167
    │ │ │ │ +
    168 // delegate instance transformation to per-node specification
    │ │ │ │ +
    169 static transformed_type transform(const S& s, T& t)
    │ │ │ │ +
    170 {
    │ │ │ │ +
    171 return NodeTransformation::transform(s,t);
    │ │ │ │ +
    172 }
    │ │ │ │ +
    173
    │ │ │ │ +
    174 // delegate instance transformation to per-node specification
    │ │ │ │ +
    175 static transformed_type transform(const S& s, const T& t)
    │ │ │ │ +
    176 {
    │ │ │ │ +
    177 return NodeTransformation::transform(s,t);
    │ │ │ │ +
    178 }
    │ │ │ │ +
    179
    │ │ │ │ +
    180 // delegate instance transformation to per-node specification
    │ │ │ │ +
    181 static transformed_type transform(std::shared_ptr<const S> sp, T& t)
    │ │ │ │
    182 {
    │ │ │ │ -
    183 _children = NodeStorage{convert_arg(std::forward<Children>(children))...};
    │ │ │ │ +
    183 return NodeTransformation::transform(sp,t);
    │ │ │ │
    184 }
    │ │ │ │
    185
    │ │ │ │ -
    186 template<typename... Children,
    │ │ │ │ -
    187 std::enable_if_t<(std::is_same_v<ChildType, std::decay_t<Children>> &&...), bool> = true>
    │ │ │ │ -
    188 DynamicPowerNode (std::shared_ptr<Children>... children)
    │ │ │ │ -
    189 {
    │ │ │ │ -
    190 _children = NodeStorage{std::move(children)...};
    │ │ │ │ -
    191 }
    │ │ │ │ -
    192
    │ │ │ │ -
    193#endif // DOXYGEN
    │ │ │ │ -
    194
    │ │ │ │ +
    186 // delegate instance transformation to per-node specification
    │ │ │ │ +
    187 static transformed_type transform(std::shared_ptr<const S> sp, const T& t)
    │ │ │ │ +
    188 {
    │ │ │ │ +
    189 return NodeTransformation::transform(sp,t);
    │ │ │ │ +
    190 }
    │ │ │ │ +
    191
    │ │ │ │ +
    192 static transformed_storage_type transform_storage(std::shared_ptr<const S> sp, T& t)
    │ │ │ │ +
    193 {
    │ │ │ │ +
    194 return NodeTransformation::transform_storage(sp,t);
    │ │ │ │ +
    195 }
    │ │ │ │
    196
    │ │ │ │ -
    197 private:
    │ │ │ │ -
    198 NodeStorage _children;
    │ │ │ │ -
    199 };
    │ │ │ │ -
    │ │ │ │ -
    200
    │ │ │ │ -
    202
    │ │ │ │ -
    203 } // namespace TypeTree
    │ │ │ │ -
    204} //namespace Dune
    │ │ │ │ -
    205
    │ │ │ │ -
    206#endif // DUNE_TYPETREE_DYNAMICPOWERNODE_HH
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ +
    197 static transformed_storage_type transform_storage(std::shared_ptr<const S> sp, const T& t)
    │ │ │ │ +
    198 {
    │ │ │ │ +
    199 return NodeTransformation::transform_storage(sp,t);
    │ │ │ │ +
    200 }
    │ │ │ │ +
    201
    │ │ │ │ +
    202 };
    │ │ │ │ +
    203
    │ │ │ │ +
    204
    │ │ │ │ +
    205 // common implementation for non-recursive transformation of non-leaf nodes
    │ │ │ │ +
    206 template<typename S, typename T>
    │ │ │ │ +
    207 struct TransformTreeNonRecursive
    │ │ │ │ +
    208 {
    │ │ │ │ +
    209 // get transformed type from specification
    │ │ │ │ +
    210 typedef typename LookupNodeTransformation<S,T,ImplementationTag<S>>::type NodeTransformation;
    │ │ │ │ +
    211
    │ │ │ │ +
    212 typedef typename NodeTransformation::transformed_type transformed_type;
    │ │ │ │ +
    213 typedef typename NodeTransformation::transformed_storage_type transformed_storage_type;
    │ │ │ │ +
    214
    │ │ │ │ +
    215 // delegate instance transformation to per-node specification
    │ │ │ │ +
    216 static transformed_type transform(const S& s, T& t)
    │ │ │ │ +
    217 {
    │ │ │ │ +
    218 return NodeTransformation::transform(s,t);
    │ │ │ │ +
    219 }
    │ │ │ │ +
    220
    │ │ │ │ +
    221 // delegate instance transformation to per-node specification
    │ │ │ │ +
    222 static transformed_type transform(const S& s, const T& t)
    │ │ │ │ +
    223 {
    │ │ │ │ +
    224 return NodeTransformation::transform(s,t);
    │ │ │ │ +
    225 }
    │ │ │ │ +
    226
    │ │ │ │ +
    227 // delegate instance transformation to per-node specification
    │ │ │ │ +
    228 static transformed_type transform(std::shared_ptr<const S> sp, T& t)
    │ │ │ │ +
    229 {
    │ │ │ │ +
    230 return NodeTransformation::transform(sp,t);
    │ │ │ │ +
    231 }
    │ │ │ │ +
    232
    │ │ │ │ +
    233 // delegate instance transformation to per-node specification
    │ │ │ │ +
    234 static transformed_type transform(std::shared_ptr<const S> sp, const T& t)
    │ │ │ │ +
    235 {
    │ │ │ │ +
    236 return NodeTransformation::transform(sp,t);
    │ │ │ │ +
    237 }
    │ │ │ │ +
    238
    │ │ │ │ +
    239 static transformed_storage_type transform_storage(std::shared_ptr<const S> sp, T& t)
    │ │ │ │ +
    240 {
    │ │ │ │ +
    241 return NodeTransformation::transform_storage(sp,t);
    │ │ │ │ +
    242 }
    │ │ │ │ +
    243
    │ │ │ │ +
    244 static transformed_storage_type transform_storage(std::shared_ptr<const S> sp, const T& t)
    │ │ │ │ +
    245 {
    │ │ │ │ +
    246 return NodeTransformation::transform_storage(sp,t);
    │ │ │ │ +
    247 }
    │ │ │ │ +
    248
    │ │ │ │ +
    249 };
    │ │ │ │ +
    250
    │ │ │ │ +
    251
    │ │ │ │ +
    252 namespace Impl {
    │ │ │ │ +
    253
    │ │ │ │ +
    254 // Helper class to handle recursive power nodes
    │ │ │ │ +
    255 template<class Source, class Transformation, class Tag>
    │ │ │ │ +
    256 class RecursivePowerTransformTree
    │ │ │ │ +
    257 {
    │ │ │ │ +
    258 // We only know two types of tags!
    │ │ │ │ +
    259 static_assert(std::is_same_v<Tag,PowerNodeTag> or std::is_same_v<Tag,DynamicPowerNodeTag>);
    │ │ │ │ +
    260
    │ │ │ │ +
    261 using ChildType = typename Source::ChildType;
    │ │ │ │ +
    262
    │ │ │ │ +
    263 // in case degree is dynamic, provid a vector correctly initialized
    │ │ │ │ +
    264 template<class NodeStorage>
    │ │ │ │ +
    265 static auto node_storage_provider(const std::size_t& degree)
    │ │ │ │ +
    266 {
    │ │ │ │ +
    267 return std::vector<NodeStorage>(degree);
    │ │ │ │ +
    268 }
    │ │ │ │ +
    269
    │ │ │ │ +
    270 // in case degree is static, provid an array
    │ │ │ │ +
    271 template<class NodeStorage, class StaticIndex>
    │ │ │ │ +
    272 static auto node_storage_provider(StaticIndex)
    │ │ │ │ +
    273 {
    │ │ │ │ +
    274 return std::array<NodeStorage,std::size_t(StaticIndex{})>();
    │ │ │ │ +
    275 }
    │ │ │ │ +
    276
    │ │ │ │ +
    277 public:
    │ │ │ │ +
    278 // get transformed type from specification
    │ │ │ │ +
    279 // Handling this transformation in a way that makes the per-node specification easy to write
    │ │ │ │ +
    280 // is a little involved:
    │ │ │ │ +
    281 // The problem is that the transformed power node must be parameterized on the transformed child
    │ │ │ │ +
    282 // type. So we need to transform the child type and pass the transformed child type to an inner
    │ │ │ │ +
    283 // template of the node transformation struct called result (see example of such a specification
    │ │ │ │ +
    284 // further down).
    │ │ │ │ +
    285 using NodeTransformation = typename LookupNodeTransformation<Source,Transformation,ImplementationTag<Source>>::type;
    │ │ │ │ +
    286 using ChildNodeTransformation = typename LookupNodeTransformation<ChildType,Transformation,ImplementationTag<ChildType>>::type;
    │ │ │ │ +
    287
    │ │ │ │ +
    288 private:
    │ │ │ │ +
    289 // Since every child is same type, is enough to get transformation once
    │ │ │ │ +
    290 using ChildTreeTransformation = TransformTree<ChildType,
    │ │ │ │ +
    291 Transformation,
    │ │ │ │ +
    292 NodeTag<ChildType>,
    │ │ │ │ +
    293 ChildNodeTransformation::recursive>;
    │ │ │ │ +
    294
    │ │ │ │ +
    295 // Get transformed type of children
    │ │ │ │ +
    296 using transformed_child_type = typename ChildTreeTransformation::transformed_type;
    │ │ │ │ +
    297 using transformed_child_storage_type = typename ChildTreeTransformation::transformed_storage_type;
    │ │ │ │ +
    298 public:
    │ │ │ │ +
    299 // Apply transformation from children to current node
    │ │ │ │ +
    300 using transformed_type = typename NodeTransformation::template result<transformed_child_type>::type;
    │ │ │ │ +
    301 using transformed_storage_type = typename NodeTransformation::template result<transformed_child_type>::storage_type;
    │ │ │ │ +
    302
    │ │ │ │ +
    303 // Transform an instance of source tree.
    │ │ │ │ +
    304 static transformed_type transform(const Source& source, Transformation& transformation)
    │ │ │ │ +
    305 {
    │ │ │ │ +
    306 auto children_storage = node_storage_provider<std::shared_ptr<transformed_child_type>>(source.degree());
    │ │ │ │ +
    307 for (std::size_t k = 0; k < source.degree(); ++k) {
    │ │ │ │ +
    308 children_storage[k] = ChildTreeTransformation::transform_storage(source.childStorage(k),transformation);
    │ │ │ │ +
    309 }
    │ │ │ │ +
    310 return NodeTransformation::transform(source,transformation,children_storage);
    │ │ │ │ +
    311 }
    │ │ │ │ +
    312
    │ │ │ │ +
    313 // Transform an instance of source tree.
    │ │ │ │ +
    314 static transformed_type transform(const Source& source, const Transformation& transformation)
    │ │ │ │ +
    315 {
    │ │ │ │ +
    316 auto children_storage = node_storage_provider<std::shared_ptr<transformed_child_type>>(source.degree());
    │ │ │ │ +
    317 for (std::size_t k = 0; k < source.degree(); ++k) {
    │ │ │ │ +
    318 children_storage[k] = ChildTreeTransformation::transform_storage(source.childStorage(k),transformation);
    │ │ │ │ +
    319 }
    │ │ │ │ +
    320 return NodeTransformation::transform(source,transformation,children_storage);
    │ │ │ │ +
    321 }
    │ │ │ │ +
    322
    │ │ │ │ +
    323 // Transform an instance of source tree.
    │ │ │ │ +
    324 static transformed_type transform(std::shared_ptr<const Source> source_ptr, Transformation& transformation)
    │ │ │ │ +
    325 {
    │ │ │ │ +
    326 auto children_storage = node_storage_provider<std::shared_ptr<transformed_child_type>>(source_ptr->degree());
    │ │ │ │ +
    327 for (std::size_t k = 0; k < source_ptr->degree(); ++k) {
    │ │ │ │ +
    328 children_storage[k] = ChildTreeTransformation::transform_storage(source_ptr->childStorage(k),transformation);
    │ │ │ │ +
    329 }
    │ │ │ │ +
    330 return NodeTransformation::transform(source_ptr,transformation,children_storage);
    │ │ │ │ +
    331 }
    │ │ │ │ +
    332
    │ │ │ │ +
    333 // Transform an instance of source tree.
    │ │ │ │ +
    334 static transformed_type transform(std::shared_ptr<const Source> source_ptr, const Transformation& transformation)
    │ │ │ │ +
    335 {
    │ │ │ │ +
    336 auto children_storage = node_storage_provider<std::shared_ptr<transformed_child_type>>(source_ptr->degree());
    │ │ │ │ +
    337 for (std::size_t k = 0; k < source_ptr->degree(); ++k) {
    │ │ │ │ +
    338 children_storage[k] = ChildTreeTransformation::transform_storage(source_ptr->childStorage(k),transformation);
    │ │ │ │ +
    339 }
    │ │ │ │ +
    340 return NodeTransformation::transform(source_ptr,transformation,children_storage);
    │ │ │ │ +
    341 }
    │ │ │ │ +
    342
    │ │ │ │ +
    343 // Transform an instance of source tree ptr.
    │ │ │ │ +
    344 static transformed_storage_type transform_storage(std::shared_ptr<const Source> source_ptr, Transformation& transformation)
    │ │ │ │ +
    345 {
    │ │ │ │ +
    346 auto children_storage = node_storage_provider<transformed_child_storage_type>(source_ptr->degree());
    │ │ │ │ +
    347 for (std::size_t k = 0; k < source_ptr->degree(); ++k) {
    │ │ │ │ +
    348 children_storage[k] = ChildTreeTransformation::transform_storage(source_ptr->childStorage(k),transformation);
    │ │ │ │ +
    349 }
    │ │ │ │ +
    350 return NodeTransformation::transform_storage(source_ptr,transformation,children_storage);
    │ │ │ │ +
    351 }
    │ │ │ │ +
    352
    │ │ │ │ +
    353 // Transform an instance of source tree ptr.
    │ │ │ │ +
    354 static transformed_storage_type transform_storage(std::shared_ptr<const Source> source_ptr, const Transformation& transformation)
    │ │ │ │ +
    355 {
    │ │ │ │ +
    356 auto children_storage = node_storage_provider<transformed_child_storage_type>(source_ptr->degree());
    │ │ │ │ +
    357 for (std::size_t k = 0; k < source_ptr->degree(); ++k) {
    │ │ │ │ +
    358 children_storage[k] = ChildTreeTransformation::transform_storage(source_ptr->childStorage(k),transformation);
    │ │ │ │ +
    359 }
    │ │ │ │ +
    360 return NodeTransformation::transform_storage(source_ptr,transformation,children_storage);
    │ │ │ │ +
    361 }
    │ │ │ │ +
    362
    │ │ │ │ +
    363 };
    │ │ │ │ +
    364 } // namespace Impl
    │ │ │ │ +
    365
    │ │ │ │ +
    366 // Recursive version of the PowerNode transformation for static nodes.
    │ │ │ │ +
    367 template<typename Source, typename Transformation>
    │ │ │ │ +
    368 struct TransformTree<Source,Transformation,PowerNodeTag,true>
    │ │ │ │ +
    369 : public Impl::RecursivePowerTransformTree<Source,Transformation,PowerNodeTag>
    │ │ │ │ +
    370 {};
    │ │ │ │ +
    371
    │ │ │ │ +
    372 // Recursive version of the DynamicPowerNode transformation for static nodes.
    │ │ │ │ +
    373 template<typename Source, typename Transformation>
    │ │ │ │ +
    374 struct TransformTree<Source,Transformation,DynamicPowerNodeTag,true>
    │ │ │ │ +
    375 : public Impl::RecursivePowerTransformTree<Source,Transformation,DynamicPowerNodeTag>
    │ │ │ │ +
    376 {};
    │ │ │ │ +
    377
    │ │ │ │ +
    378 // non-recursive version of the PowerNode transformation.
    │ │ │ │ +
    379 template<typename S, typename T>
    │ │ │ │ +
    380 struct TransformTree<S,T,PowerNodeTag,false>
    │ │ │ │ +
    381 : public TransformTreeNonRecursive<S,T>
    │ │ │ │ +
    382 {};
    │ │ │ │ +
    383
    │ │ │ │ +
    384 // non-recursive version of the DynamicPowerNodeTag transformation.
    │ │ │ │ +
    385 template<typename S, typename T>
    │ │ │ │ +
    386 struct TransformTree<S,T,DynamicPowerNodeTag,false>
    │ │ │ │ +
    387 : public TransformTreeNonRecursive<S,T>
    │ │ │ │ +
    388 {};
    │ │ │ │ +
    389
    │ │ │ │ +
    390 // helper struct that does the actual transformation for a composite node. We need this additional struct
    │ │ │ │ +
    391 // to extract the template argument list with the types of all children from the node, which we cannot do
    │ │ │ │ +
    392 // directly in the transformation<> template, as the type passed to transformation<> will usually be a
    │ │ │ │ +
    393 // derived type and will normally have more template arguments than just the children. This declaration
    │ │ │ │ +
    394 // just introduces the type of the helper struct, we always instantiate the specialization defined below;
    │ │ │ │ +
    395 template<typename S, typename Children, typename T>
    │ │ │ │ +
    396 struct transform_composite_node;
    │ │ │ │ +
    397
    │ │ │ │ +
    398 // specialized version of the helper struct which extracts the template argument list with the children from
    │ │ │ │ +
    399 // its second template parameter, which has to be CompositeNode::ChildTypes. Apart from that, the struct is
    │ │ │ │ +
    400 // similar to the one for a PowerNode, but it obviously delegates transformation of the children to the TMP.
    │ │ │ │ +
    401 template<typename S, typename T, typename... C>
    │ │ │ │ +
    402 struct transform_composite_node<S,std::tuple<C...>,T>
    │ │ │ │ +
    403 {
    │ │ │ │ +
    404
    │ │ │ │ +
    405 // transformed type, using the same nested struct trick as the PowerNode
    │ │ │ │ +
    406 typedef ImplementationTag<S> Tag;
    │ │ │ │ +
    407 typedef typename LookupNodeTransformation<S,T,Tag>::type NodeTransformation;
    │ │ │ │ +
    408 typedef typename NodeTransformation::template result<typename TransformTree<C,
    │ │ │ │ +
    409 T,
    │ │ │ │ +
    410 NodeTag<C>,
    │ │ │ │ +
    411 LookupNodeTransformation<C,T,ImplementationTag<C>>::type::recursive
    │ │ │ │ +
    412 >::transformed_type...
    │ │ │ │ +
    413 >::type transformed_type;
    │ │ │ │ +
    414
    │ │ │ │ +
    415 typedef typename NodeTransformation::template result<typename TransformTree<C,
    │ │ │ │ +
    416 T,
    │ │ │ │ +
    417 NodeTag<C>,
    │ │ │ │ +
    418 LookupNodeTransformation<C,T,ImplementationTag<C>>::type::recursive
    │ │ │ │ +
    419 >::transformed_type...
    │ │ │ │ +
    420 >::storage_type transformed_storage_type;
    │ │ │ │ +
    421
    │ │ │ │ +
    422 // Retrieve the transformation descriptor for the child with index i.
    │ │ │ │ +
    423 // This little helper improves really improves the readability of the
    │ │ │ │ +
    424 // transformation functions.
    │ │ │ │ +
    425 template<std::size_t i>
    │ │ │ │ +
    426 struct ChildTransformation
    │ │ │ │ +
    427 : public TransformTree<typename S::template Child<i>::Type,
    │ │ │ │ +
    428 T,
    │ │ │ │ +
    429 NodeTag<typename S::template Child<i>::Type>,
    │ │ │ │ +
    430 LookupNodeTransformation<
    │ │ │ │ +
    431 typename S::template Child<i>::Type,
    │ │ │ │ +
    432 T,
    │ │ │ │ +
    433 ImplementationTag<typename S::template Child<i>::Type>
    │ │ │ │ +
    434 >::type::recursive
    │ │ │ │ +
    435 >
    │ │ │ │ +
    436 {};
    │ │ │ │ +
    437
    │ │ │ │ +
    438 template<std::size_t i, typename Tuple, typename Value>
    │ │ │ │ +
    439 static void setElement(Tuple& tuple, Value&& value)
    │ │ │ │ +
    440 {
    │ │ │ │ +
    441 std::get<i>(tuple) = std::forward<Value>(value);
    │ │ │ │ +
    442 }
    │ │ │ │ +
    443
    │ │ │ │ +
    444 template<typename Trafo, std::size_t... i>
    │ │ │ │ +
    445 static transformed_type transform(const S& s, Trafo&& t, std::index_sequence<i...> indices)
    │ │ │ │ +
    446 {
    │ │ │ │ +
    447 std::tuple<typename ChildTransformation<i>::transformed_storage_type...> storage;
    │ │ │ │ +
    448 Dune::Hybrid::Impl::evaluateFoldExpression<int>({(setElement<i>(storage, ChildTransformation<i>::transform_storage(s.template childStorage<i>(), std::forward<Trafo>(t))),0)...});
    │ │ │ │ +
    449 return NodeTransformation::transform(s, std::forward<Trafo>(t), std::get<i>(storage)...);
    │ │ │ │ +
    450 }
    │ │ │ │ +
    451
    │ │ │ │ +
    452 template<typename Trafo, std::size_t... i>
    │ │ │ │ +
    453 static transformed_storage_type transform_storage(std::shared_ptr<const S> sp, Trafo&& t, std::index_sequence<i...> indices)
    │ │ │ │ +
    454 {
    │ │ │ │ +
    455 std::tuple<typename ChildTransformation<i>::transformed_storage_type...> storage;
    │ │ │ │ +
    456 Dune::Hybrid::Impl::evaluateFoldExpression<int>({(setElement<i>(storage, ChildTransformation<i>::transform_storage(sp->template childStorage<i>(), std::forward<Trafo>(t))),0)...});
    │ │ │ │ +
    457 return NodeTransformation::transform_storage(sp, std::forward<Trafo>(t), std::get<i>(storage)...);
    │ │ │ │ +
    458 }
    │ │ │ │ +
    459 };
    │ │ │ │ +
    460
    │ │ │ │ +
    461
    │ │ │ │ +
    462 // the specialization of transformation<> for the CompositeNode. This just extracts the
    │ │ │ │ +
    463 // CompositeNode::ChildTypes member and forwards to the helper struct
    │ │ │ │ +
    464 template<typename S, typename T>
    │ │ │ │ +
    465 struct TransformTree<S,T,CompositeNodeTag,true>
    │ │ │ │ +
    466 {
    │ │ │ │ +
    467
    │ │ │ │ +
    468 private:
    │ │ │ │ +
    469
    │ │ │ │ +
    470 typedef typename S::ChildTypes ChildTypes;
    │ │ │ │ +
    471
    │ │ │ │ +
    472 static auto child_indices()
    │ │ │ │ +
    473 {
    │ │ │ │ +
    474 return std::make_index_sequence<S::degree()>();
    │ │ │ │ +
    475 }
    │ │ │ │ +
    476
    │ │ │ │ +
    477 public:
    │ │ │ │ +
    478
    │ │ │ │ +
    479 typedef typename transform_composite_node<S,ChildTypes,T>::transformed_type transformed_type;
    │ │ │ │ +
    480 typedef typename transform_composite_node<S,ChildTypes,T>::transformed_storage_type transformed_storage_type;
    │ │ │ │ +
    481
    │ │ │ │ +
    482 static transformed_type transform(const S& s, T& t)
    │ │ │ │ +
    483 {
    │ │ │ │ +
    484 return transform_composite_node<S,ChildTypes,T>::transform(s,t,child_indices());
    │ │ │ │ +
    485 }
    │ │ │ │ +
    486
    │ │ │ │ +
    487 static transformed_type transform(const S& s, const T& t)
    │ │ │ │ +
    488 {
    │ │ │ │ +
    489 return transform_composite_node<S,ChildTypes,T>::transform(s,t,child_indices());
    │ │ │ │ +
    490 }
    │ │ │ │ +
    491
    │ │ │ │ +
    492 static transformed_storage_type transform_storage(std::shared_ptr<const S> sp, T& t)
    │ │ │ │ +
    493 {
    │ │ │ │ +
    494 return transform_composite_node<S,ChildTypes,T>::transform_storage(sp,t,child_indices());
    │ │ │ │ +
    495 }
    │ │ │ │ +
    496
    │ │ │ │ +
    497 static transformed_storage_type transform_storage(std::shared_ptr<const S> sp, const T& t)
    │ │ │ │ +
    498 {
    │ │ │ │ +
    499 return transform_composite_node<S,ChildTypes,T>::transform_storage(sp,t,child_indices());
    │ │ │ │ +
    500 }
    │ │ │ │ +
    501
    │ │ │ │ +
    502 };
    │ │ │ │ +
    503
    │ │ │ │ +
    504 // non-recursive version of the CompositeNode transformation.
    │ │ │ │ +
    505 template<typename S, typename T>
    │ │ │ │ +
    506 struct TransformTree<S,T,CompositeNodeTag,false>
    │ │ │ │ +
    507 : public TransformTreeNonRecursive<S,T>
    │ │ │ │ +
    508 {};
    │ │ │ │ +
    509
    │ │ │ │ +
    510#endif // DOXYGEN
    │ │ │ │ +
    511
    │ │ │ │ +
    513
    │ │ │ │ +
    514 } // namespace TypeTree
    │ │ │ │ +
    515} //namespace Dune
    │ │ │ │ +
    516
    │ │ │ │ +
    517#endif // DUNE_TYPETREE_TRANSFORMATION_HH
    │ │ │ │ + │ │ │ │ +
    result
    static const result_type result
    Definition accumulate_static.hh:113
    │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::registerNodeTransformation
    void registerNodeTransformation(SourceNode *, Transformation *, Tag *)
    Register transformation descriptor to transform SourceNode with Transformation.
    │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode
    Collect multiple instances of type T within a dune-typetree.
    Definition dynamicpowernode.hh:35
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::isPower
    static const bool isPower
    Mark this class as a power in the dune-typetree.
    Definition dynamicpowernode.hh:43
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::NodeStorage
    std::vector< ChildStorageType > NodeStorage
    The type used for storing the children.
    Definition dynamicpowernode.hh:67
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::nodeStorage
    const NodeStorage & nodeStorage() const
    Definition dynamicpowernode.hh:137
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::childStorage
    ChildConstStorageType childStorage(std::size_t i) const
    Returns the storage of the i-th child (const version).
    Definition dynamicpowernode.hh:110
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::child
    const ChildType & child(std::size_t i) const
    Returns the i-th child (const version).
    Definition dynamicpowernode.hh:87
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::ChildStorageType
    std::shared_ptr< T > ChildStorageType
    The storage type of each child.
    Definition dynamicpowernode.hh:61
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::DynamicPowerNode
    DynamicPowerNode(T &t1, T &t2,...)
    Initialize all children with the passed-in objects.
    Definition dynamicpowernode.hh:174
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::ChildConstStorageType
    std::shared_ptr< const T > ChildConstStorageType
    The const version of the storage type of each child.
    Definition dynamicpowernode.hh:64
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::DynamicPowerNode
    DynamicPowerNode(NodeStorage children)
    Initialize the DynamicPowerNode with a copy of the passed-in storage type.
    Definition dynamicpowernode.hh:167
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::NodeTag
    DynamicPowerNodeTag NodeTag
    The type tag that describes the node.
    Definition dynamicpowernode.hh:55
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::ChildType
    T ChildType
    The type of each child.
    Definition dynamicpowernode.hh:58
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::setChild
    void setChild(std::size_t i, ChildType &t)
    Sets the i-th child to the passed-in value.
    Definition dynamicpowernode.hh:117
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::setChild
    void setChild(std::size_t i, ChildStorageType st)
    Sets the stored value representing the i-th child to the passed-in value.
    Definition dynamicpowernode.hh:131
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::DynamicPowerNode
    DynamicPowerNode(std::size_t size)
    Construct a node with the given number of children.
    Definition dynamicpowernode.hh:162
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::isComposite
    static const bool isComposite
    Mark this class as a non composite in the dune-typetree.
    Definition dynamicpowernode.hh:46
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::setChild
    void setChild(std::size_t i, ChildType &&t)
    Store the passed value in i-th child.
    Definition dynamicpowernode.hh:124
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::child
    ChildType & child(std::size_t i)
    Returns the i-th child.
    Definition dynamicpowernode.hh:77
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::degree
    std::size_t degree() const
    The number of children.
    Definition dynamicpowernode.hh:49
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::childStorage
    ChildStorageType childStorage(std::size_t i)
    Returns the storage of the i-th child.
    Definition dynamicpowernode.hh:97
    │ │ │ │ -
    Dune::TypeTree::DynamicPowerNode::isLeaf
    static const bool isLeaf
    Mark this class as non leaf in the dune-typetree.
    Definition dynamicpowernode.hh:40
    │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::DynamicPowerNodeTag
    Tag designating a power node with runtime degree.
    Definition nodetags.hh:24
    │ │ │ │ +
    Dune::TypeTree::TransformTree
    Transform a TypeTree.
    Definition transformation.hh:96
    │ │ │ │ +
    Dune::TypeTree::TransformTree::Type
    type Type
    Definition transformation.hh:113
    │ │ │ │ +
    Dune::TypeTree::TransformTree::transform
    static transformed_type transform(std::shared_ptr< const SourceTree > sp, Transformation &t)
    Apply transformation to an existing tree s.
    Definition transformation.hh:134
    │ │ │ │ +
    Dune::TypeTree::TransformTree::transform
    static transformed_type transform(std::shared_ptr< const SourceTree > sp, const Transformation &t=Transformation())
    Apply transformation to an existing tree s.
    Definition transformation.hh:128
    │ │ │ │ +
    Dune::TypeTree::TransformTree::transform
    static transformed_type transform(const SourceTree &s, Transformation &t)
    Apply transformation to an existing tree s.
    Definition transformation.hh:122
    │ │ │ │ +
    Dune::TypeTree::TransformTree::type
    transformed_type type
    The type of the transformed tree.
    Definition transformation.hh:111
    │ │ │ │ +
    Dune::TypeTree::TransformTree::transform
    static transformed_type transform(const SourceTree &s, const Transformation &t=Transformation())
    Apply transformation to an existing tree s.
    Definition transformation.hh:116
    │ │ │ │ +
    Dune::TypeTree::TransformTree::transform_storage
    static transformed_storage_type transform_storage(std::shared_ptr< const SourceTree > sp, const Transformation &t=Transformation())
    Definition transformation.hh:141
    │ │ │ │ +
    Dune::TypeTree::TransformTree::transform_storage
    static transformed_storage_type transform_storage(std::shared_ptr< const SourceTree > sp, Transformation &t)
    Definition transformation.hh:148
    │ │ │ │ +
    Dune::TypeTree::evaluate_if_meta_function
    Meta function that evaluates its argument iff it inherits from meta_function.
    Definition typetraits.hh:142
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,257 +1,634 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -dynamicpowernode.hh │ │ │ │ │ +transformation.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_DYNAMICPOWERNODE_HH │ │ │ │ │ -7#define DUNE_TYPETREE_DYNAMICPOWERNODE_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_TRANSFORMATION_HH │ │ │ │ │ +7#define DUNE_TYPETREE_TRANSFORMATION_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include │ │ │ │ │ -10#include │ │ │ │ │ +9#include │ │ │ │ │ +10#include │ │ │ │ │ 11#include │ │ │ │ │ -12#include │ │ │ │ │ +12#include │ │ │ │ │ 13 │ │ │ │ │ -14#include │ │ │ │ │ -15#include │ │ │ │ │ -16 │ │ │ │ │ -17#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ -18#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_u_t_i_l_i_t_y_._h_h> │ │ │ │ │ -19#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_y_p_e_t_r_a_i_t_s_._h_h> │ │ │ │ │ -20 │ │ │ │ │ -21namespace _D_u_n_e { │ │ │ │ │ -22 namespace TypeTree { │ │ │ │ │ -23 │ │ │ │ │ -33 template │ │ │ │ │ -_3_4 class _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e │ │ │ │ │ -35 { │ │ │ │ │ -36 │ │ │ │ │ -37 public: │ │ │ │ │ -38 │ │ │ │ │ -_4_0 static const bool _i_s_L_e_a_f = false; │ │ │ │ │ -41 │ │ │ │ │ -_4_3 static const bool _i_s_P_o_w_e_r = true; │ │ │ │ │ -44 │ │ │ │ │ -_4_6 static const bool _i_s_C_o_m_p_o_s_i_t_e = false; │ │ │ │ │ -47 │ │ │ │ │ -_4_9 std::size_t _d_e_g_r_e_e() const │ │ │ │ │ -50 { │ │ │ │ │ -51 return _children.size(); │ │ │ │ │ -52 } │ │ │ │ │ -53 │ │ │ │ │ -_5_5 typedef _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g _N_o_d_e_T_a_g; │ │ │ │ │ -56 │ │ │ │ │ -_5_8 typedef T _C_h_i_l_d_T_y_p_e; │ │ │ │ │ -59 │ │ │ │ │ -_6_1 typedef std::shared_ptr _C_h_i_l_d_S_t_o_r_a_g_e_T_y_p_e; │ │ │ │ │ -62 │ │ │ │ │ -_6_4 typedef std::shared_ptr _C_h_i_l_d_C_o_n_s_t_S_t_o_r_a_g_e_T_y_p_e; │ │ │ │ │ -65 │ │ │ │ │ -_6_7 typedef std::vector _N_o_d_e_S_t_o_r_a_g_e; │ │ │ │ │ -68 │ │ │ │ │ -69 │ │ │ │ │ -72 │ │ │ │ │ -74 │ │ │ │ │ -_7_7 _C_h_i_l_d_T_y_p_e& _c_h_i_l_d (std::size_t i) │ │ │ │ │ -78 { │ │ │ │ │ -79 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ -80 return *_children[i]; │ │ │ │ │ -81 } │ │ │ │ │ +14#include │ │ │ │ │ +15#include │ │ │ │ │ +16#include │ │ │ │ │ +17#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_y_p_e_t_r_a_i_t_s_._h_h> │ │ │ │ │ +18#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> │ │ │ │ │ +19#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ +20#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_u_t_i_l_i_t_y_._h_h> │ │ │ │ │ +21 │ │ │ │ │ +22 │ │ │ │ │ +23namespace _D_u_n_e { │ │ │ │ │ +24 namespace TypeTree { │ │ │ │ │ +25 │ │ │ │ │ +31#ifdef DOXYGEN │ │ │ │ │ +32 │ │ │ │ │ +34 │ │ │ │ │ +53 template │ │ │ │ │ +_5_4 void _r_e_g_i_s_t_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n(SourceNode*, Transformation*, Tag*); │ │ │ │ │ +55 │ │ │ │ │ +56#else // DOXYGEN │ │ │ │ │ +57 │ │ │ │ │ +68 template │ │ │ │ │ +69 struct LookupNodeTransformation │ │ │ │ │ +70 { │ │ │ │ │ +71 │ │ │ │ │ +72 typedef decltype(_r_e_g_i_s_t_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n(declptr(),declptr │ │ │ │ │ +(),declptr())) lookup_type; │ │ │ │ │ +73 │ │ │ │ │ +74 typedef typename _e_v_a_l_u_a_t_e___i_f___m_e_t_a___f_u_n_c_t_i_o_n< │ │ │ │ │ +75 lookup_type │ │ │ │ │ +76 >::type type; │ │ │ │ │ +77 │ │ │ │ │ +78 static_assert((!std::is_same::value), "Unable to find valid │ │ │ │ │ +transformation descriptor"); │ │ │ │ │ +79 }; │ │ │ │ │ +80 │ │ │ │ │ +81#endif // DOXYGEN │ │ │ │ │ 82 │ │ │ │ │ -84 │ │ │ │ │ -_8_7 const _C_h_i_l_d_T_y_p_e& _c_h_i_l_d (std::size_t i) const │ │ │ │ │ -88 { │ │ │ │ │ -89 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ -90 return *_children[i]; │ │ │ │ │ -91 } │ │ │ │ │ -92 │ │ │ │ │ -94 │ │ │ │ │ -_9_7 _C_h_i_l_d_S_t_o_r_a_g_e_T_y_p_e _c_h_i_l_d_S_t_o_r_a_g_e (std::size_t i) │ │ │ │ │ -98 { │ │ │ │ │ -99 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ -100 return _children[i]; │ │ │ │ │ -101 } │ │ │ │ │ -102 │ │ │ │ │ +83 │ │ │ │ │ +85 │ │ │ │ │ +94 template │ │ │ │ │ +_9_5 struct _T_r_a_n_s_f_o_r_m_T_r_e_e │ │ │ │ │ +96 { │ │ │ │ │ +97 │ │ │ │ │ +98#ifndef DOXYGEN │ │ │ │ │ +99 │ │ │ │ │ +100 typedef typename │ │ │ │ │ +LookupNodeTransformation::type NodeTransformation; │ │ │ │ │ +101 │ │ │ │ │ +102 // the type of the new tree that will result from this transformation │ │ │ │ │ +103 typedef typename │ │ │ │ │ +_T_r_a_n_s_f_o_r_m_T_r_e_e_<_S_o_u_r_c_e_T_r_e_e_,_T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_N_o_d_e_T_a_g_<_S_o_u_r_c_e_T_r_e_e_>,NodeTransformation:: │ │ │ │ │ +recursive>::transformed_type transformed_type; │ │ │ │ │ 104 │ │ │ │ │ -_1_1_0 _C_h_i_l_d_C_o_n_s_t_S_t_o_r_a_g_e_T_y_p_e _c_h_i_l_d_S_t_o_r_a_g_e (std::size_t i) const │ │ │ │ │ -111 { │ │ │ │ │ -112 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ -113 return _children[i]; │ │ │ │ │ -114 } │ │ │ │ │ -115 │ │ │ │ │ -_1_1_7 void _s_e_t_C_h_i_l_d (std::size_t i, _C_h_i_l_d_T_y_p_e& t) │ │ │ │ │ -118 { │ │ │ │ │ -119 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ -120 _children[i] = stackobject_to_shared_ptr(t); │ │ │ │ │ -121 } │ │ │ │ │ -122 │ │ │ │ │ -_1_2_4 void _s_e_t_C_h_i_l_d (std::size_t i, _C_h_i_l_d_T_y_p_e&& t) │ │ │ │ │ -125 { │ │ │ │ │ -126 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ -127 _children[i] = convert_arg(std::move(t)); │ │ │ │ │ -128 } │ │ │ │ │ -129 │ │ │ │ │ -_1_3_1 void _s_e_t_C_h_i_l_d (std::size_t i, _C_h_i_l_d_S_t_o_r_a_g_e_T_y_p_e st) │ │ │ │ │ -132 { │ │ │ │ │ -133 assert(i < _d_e_g_r_e_e() && "child index out of range"); │ │ │ │ │ -134 _children[i] = std::move(st); │ │ │ │ │ -135 } │ │ │ │ │ -136 │ │ │ │ │ -_1_3_7 const _N_o_d_e_S_t_o_r_a_g_e& _n_o_d_e_S_t_o_r_a_g_e () const │ │ │ │ │ -138 { │ │ │ │ │ -139 return _children; │ │ │ │ │ -140 } │ │ │ │ │ -141 │ │ │ │ │ -143 │ │ │ │ │ -146 │ │ │ │ │ -147 protected: │ │ │ │ │ -148 │ │ │ │ │ -_1_5_1 _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e () = delete; │ │ │ │ │ +105 // the storage type of the new tree that will result from this │ │ │ │ │ +transformation │ │ │ │ │ +106 typedef typename │ │ │ │ │ +_T_r_a_n_s_f_o_r_m_T_r_e_e_<_S_o_u_r_c_e_T_r_e_e_,_T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_N_o_d_e_T_a_g_<_S_o_u_r_c_e_T_r_e_e_>,NodeTransformation:: │ │ │ │ │ +recursive>::transformed_storage_type transformed_storage_type; │ │ │ │ │ +107 │ │ │ │ │ +108#endif // DOXYGEN │ │ │ │ │ +109 │ │ │ │ │ +_1_1_1 typedef transformed_type _t_y_p_e; │ │ │ │ │ +112 │ │ │ │ │ +_1_1_3 typedef _t_y_p_e _T_y_p_e; │ │ │ │ │ +114 │ │ │ │ │ +_1_1_6 static transformed_type _t_r_a_n_s_f_o_r_m(const SourceTree& s, const │ │ │ │ │ +Transformation& t = Transformation()) │ │ │ │ │ +117 { │ │ │ │ │ +118 return │ │ │ │ │ +_T_r_a_n_s_f_o_r_m_T_r_e_e_<_S_o_u_r_c_e_T_r_e_e_,_T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_N_o_d_e_T_a_g_<_S_o_u_r_c_e_T_r_e_e_>,NodeTransformation:: │ │ │ │ │ +recursive>_:_:_t_r_a_n_s_f_o_r_m(s,t); │ │ │ │ │ +119 } │ │ │ │ │ +120 │ │ │ │ │ +_1_2_2 static transformed_type _t_r_a_n_s_f_o_r_m(const SourceTree& s, Transformation& t) │ │ │ │ │ +123 { │ │ │ │ │ +124 return │ │ │ │ │ +_T_r_a_n_s_f_o_r_m_T_r_e_e_<_S_o_u_r_c_e_T_r_e_e_,_T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_N_o_d_e_T_a_g_<_S_o_u_r_c_e_T_r_e_e_>,NodeTransformation:: │ │ │ │ │ +recursive>_:_:_t_r_a_n_s_f_o_r_m(s,t); │ │ │ │ │ +125 } │ │ │ │ │ +126 │ │ │ │ │ +_1_2_8 static transformed_type _t_r_a_n_s_f_o_r_m(std::shared_ptr sp, │ │ │ │ │ +const Transformation& t = Transformation()) │ │ │ │ │ +129 { │ │ │ │ │ +130 return │ │ │ │ │ +_T_r_a_n_s_f_o_r_m_T_r_e_e_<_S_o_u_r_c_e_T_r_e_e_,_T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_N_o_d_e_T_a_g_<_S_o_u_r_c_e_T_r_e_e_>,NodeTransformation:: │ │ │ │ │ +recursive>_:_:_t_r_a_n_s_f_o_r_m(sp,t); │ │ │ │ │ +131 } │ │ │ │ │ +132 │ │ │ │ │ +_1_3_4 static transformed_type _t_r_a_n_s_f_o_r_m(std::shared_ptr sp, │ │ │ │ │ +Transformation& t) │ │ │ │ │ +135 { │ │ │ │ │ +136 return │ │ │ │ │ +_T_r_a_n_s_f_o_r_m_T_r_e_e_<_S_o_u_r_c_e_T_r_e_e_,_T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_N_o_d_e_T_a_g_<_S_o_u_r_c_e_T_r_e_e_>,NodeTransformation:: │ │ │ │ │ +recursive>_:_:_t_r_a_n_s_f_o_r_m(sp,t); │ │ │ │ │ +137 } │ │ │ │ │ +138 │ │ │ │ │ +_1_4_1 static transformed_storage_type _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std::shared_ptr sp, const Transformation& t = Transformation()) │ │ │ │ │ +142 { │ │ │ │ │ +143 return │ │ │ │ │ +_T_r_a_n_s_f_o_r_m_T_r_e_e_<_S_o_u_r_c_e_T_r_e_e_,_T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_N_o_d_e_T_a_g_<_S_o_u_r_c_e_T_r_e_e_>,NodeTransformation:: │ │ │ │ │ +recursive>_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(sp,t); │ │ │ │ │ +144 } │ │ │ │ │ +145 │ │ │ │ │ +_1_4_8 static transformed_storage_type _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std::shared_ptr sp, Transformation& t) │ │ │ │ │ +149 { │ │ │ │ │ +150 return │ │ │ │ │ +_T_r_a_n_s_f_o_r_m_T_r_e_e_<_S_o_u_r_c_e_T_r_e_e_,_T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_N_o_d_e_T_a_g_<_S_o_u_r_c_e_T_r_e_e_>,NodeTransformation:: │ │ │ │ │ +recursive>_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(sp,t); │ │ │ │ │ +151 } │ │ │ │ │ 152 │ │ │ │ │ -154 │ │ │ │ │ -_1_6_2 explicit _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e (std::size_t size) │ │ │ │ │ -163 : _children(size) │ │ │ │ │ -164 {} │ │ │ │ │ -165 │ │ │ │ │ -_1_6_7 explicit _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e (_N_o_d_e_S_t_o_r_a_g_e children) │ │ │ │ │ -168 : _children(std::move(children)) │ │ │ │ │ -169 {} │ │ │ │ │ -170 │ │ │ │ │ -171#ifdef DOXYGEN │ │ │ │ │ -172 │ │ │ │ │ -_1_7_4 _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e (T& t1, T& t2, ...) │ │ │ │ │ -175 {} │ │ │ │ │ -176 │ │ │ │ │ -177#else │ │ │ │ │ -178 │ │ │ │ │ -179 template> &&...), │ │ │ │ │ -bool> = true> │ │ │ │ │ -181 _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e (Children&&... children) │ │ │ │ │ +153 │ │ │ │ │ +154 }; │ │ │ │ │ +155 │ │ │ │ │ +156#ifndef DOXYGEN // internal per-node implementations of the transformation │ │ │ │ │ +algorithm │ │ │ │ │ +157 │ │ │ │ │ +158 // handle a leaf node - this is easy │ │ │ │ │ +159 template │ │ │ │ │ +160 struct TransformTree │ │ │ │ │ +161 { │ │ │ │ │ +162 // get transformed type from specification │ │ │ │ │ +163 typedef typename LookupNodeTransformation>_:_:_t_y_p_e │ │ │ │ │ +NodeTransformation; │ │ │ │ │ +164 │ │ │ │ │ +165 typedef typename NodeTransformation::transformed_type transformed_type; │ │ │ │ │ +166 typedef typename NodeTransformation::transformed_storage_type │ │ │ │ │ +transformed_storage_type; │ │ │ │ │ +167 │ │ │ │ │ +168 // delegate instance transformation to per-node specification │ │ │ │ │ +169 static transformed_type _t_r_a_n_s_f_o_r_m(const S& s, T& t) │ │ │ │ │ +170 { │ │ │ │ │ +171 return NodeTransformation::transform(s,t); │ │ │ │ │ +172 } │ │ │ │ │ +173 │ │ │ │ │ +174 // delegate instance transformation to per-node specification │ │ │ │ │ +175 static transformed_type _t_r_a_n_s_f_o_r_m(const S& s, const T& t) │ │ │ │ │ +176 { │ │ │ │ │ +177 return NodeTransformation::transform(s,t); │ │ │ │ │ +178 } │ │ │ │ │ +179 │ │ │ │ │ +180 // delegate instance transformation to per-node specification │ │ │ │ │ +181 static transformed_type _t_r_a_n_s_f_o_r_m(std::shared_ptr sp, T& t) │ │ │ │ │ 182 { │ │ │ │ │ -183 _children = _N_o_d_e_S_t_o_r_a_g_e{convert_arg(std::forward(children))...}; │ │ │ │ │ +183 return NodeTransformation::transform(sp,t); │ │ │ │ │ 184 } │ │ │ │ │ 185 │ │ │ │ │ -186 template> &&...), │ │ │ │ │ -bool> = true> │ │ │ │ │ -188 _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e (std::shared_ptr... children) │ │ │ │ │ -189 { │ │ │ │ │ -190 _children = _N_o_d_e_S_t_o_r_a_g_e{std::move(children)...}; │ │ │ │ │ -191 } │ │ │ │ │ -192 │ │ │ │ │ -193#endif // DOXYGEN │ │ │ │ │ -194 │ │ │ │ │ +186 // delegate instance transformation to per-node specification │ │ │ │ │ +187 static transformed_type _t_r_a_n_s_f_o_r_m(std::shared_ptr sp, const T& t) │ │ │ │ │ +188 { │ │ │ │ │ +189 return NodeTransformation::transform(sp,t); │ │ │ │ │ +190 } │ │ │ │ │ +191 │ │ │ │ │ +192 static transformed_storage_type _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std::shared_ptr │ │ │ │ │ +sp, T& t) │ │ │ │ │ +193 { │ │ │ │ │ +194 return NodeTransformation::transform_storage(sp,t); │ │ │ │ │ +195 } │ │ │ │ │ 196 │ │ │ │ │ -197 private: │ │ │ │ │ -198 _N_o_d_e_S_t_o_r_a_g_e _children; │ │ │ │ │ -199 }; │ │ │ │ │ -200 │ │ │ │ │ -202 │ │ │ │ │ -203 } // namespace TypeTree │ │ │ │ │ -204} //namespace Dune │ │ │ │ │ -205 │ │ │ │ │ -206#endif // DUNE_TYPETREE_DYNAMICPOWERNODE_HH │ │ │ │ │ +197 static transformed_storage_type _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std::shared_ptr │ │ │ │ │ +sp, const T& t) │ │ │ │ │ +198 { │ │ │ │ │ +199 return NodeTransformation::transform_storage(sp,t); │ │ │ │ │ +200 } │ │ │ │ │ +201 │ │ │ │ │ +202 }; │ │ │ │ │ +203 │ │ │ │ │ +204 │ │ │ │ │ +205 // common implementation for non-recursive transformation of non-leaf nodes │ │ │ │ │ +206 template │ │ │ │ │ +207 struct TransformTreeNonRecursive │ │ │ │ │ +208 { │ │ │ │ │ +209 // get transformed type from specification │ │ │ │ │ +210 typedef typename LookupNodeTransformation>::type │ │ │ │ │ +NodeTransformation; │ │ │ │ │ +211 │ │ │ │ │ +212 typedef typename NodeTransformation::transformed_type transformed_type; │ │ │ │ │ +213 typedef typename NodeTransformation::transformed_storage_type │ │ │ │ │ +transformed_storage_type; │ │ │ │ │ +214 │ │ │ │ │ +215 // delegate instance transformation to per-node specification │ │ │ │ │ +216 static transformed_type transform(const S& s, T& t) │ │ │ │ │ +217 { │ │ │ │ │ +218 return NodeTransformation::transform(s,t); │ │ │ │ │ +219 } │ │ │ │ │ +220 │ │ │ │ │ +221 // delegate instance transformation to per-node specification │ │ │ │ │ +222 static transformed_type transform(const S& s, const T& t) │ │ │ │ │ +223 { │ │ │ │ │ +224 return NodeTransformation::transform(s,t); │ │ │ │ │ +225 } │ │ │ │ │ +226 │ │ │ │ │ +227 // delegate instance transformation to per-node specification │ │ │ │ │ +228 static transformed_type transform(std::shared_ptr sp, T& t) │ │ │ │ │ +229 { │ │ │ │ │ +230 return NodeTransformation::transform(sp,t); │ │ │ │ │ +231 } │ │ │ │ │ +232 │ │ │ │ │ +233 // delegate instance transformation to per-node specification │ │ │ │ │ +234 static transformed_type transform(std::shared_ptr sp, const T& t) │ │ │ │ │ +235 { │ │ │ │ │ +236 return NodeTransformation::transform(sp,t); │ │ │ │ │ +237 } │ │ │ │ │ +238 │ │ │ │ │ +239 static transformed_storage_type transform_storage(std::shared_ptr │ │ │ │ │ +sp, T& t) │ │ │ │ │ +240 { │ │ │ │ │ +241 return NodeTransformation::transform_storage(sp,t); │ │ │ │ │ +242 } │ │ │ │ │ +243 │ │ │ │ │ +244 static transformed_storage_type transform_storage(std::shared_ptr │ │ │ │ │ +sp, const T& t) │ │ │ │ │ +245 { │ │ │ │ │ +246 return NodeTransformation::transform_storage(sp,t); │ │ │ │ │ +247 } │ │ │ │ │ +248 │ │ │ │ │ +249 }; │ │ │ │ │ +250 │ │ │ │ │ +251 │ │ │ │ │ +252 namespace Impl { │ │ │ │ │ +253 │ │ │ │ │ +254 // Helper class to handle recursive power nodes │ │ │ │ │ +255 template │ │ │ │ │ +256 class RecursivePowerTransformTree │ │ │ │ │ +257 { │ │ │ │ │ +258 // We only know two types of tags! │ │ │ │ │ +259 static_assert(std::is_same_v or std:: │ │ │ │ │ +is_same_v); │ │ │ │ │ +260 │ │ │ │ │ +261 using ChildType = typename Source::ChildType; │ │ │ │ │ +262 │ │ │ │ │ +263 // in case degree is dynamic, provid a vector correctly initialized │ │ │ │ │ +264 template │ │ │ │ │ +265 static auto node_storage_provider(const std::size_t& degree) │ │ │ │ │ +266 { │ │ │ │ │ +267 return std::vector(degree); │ │ │ │ │ +268 } │ │ │ │ │ +269 │ │ │ │ │ +270 // in case degree is static, provid an array │ │ │ │ │ +271 template │ │ │ │ │ +272 static auto node_storage_provider(StaticIndex) │ │ │ │ │ +273 { │ │ │ │ │ +274 return std::array(); │ │ │ │ │ +275 } │ │ │ │ │ +276 │ │ │ │ │ +277 public: │ │ │ │ │ +278 // get transformed type from specification │ │ │ │ │ +279 // Handling this transformation in a way that makes the per-node │ │ │ │ │ +specification easy to write │ │ │ │ │ +280 // is a little involved: │ │ │ │ │ +281 // The problem is that the transformed power node must be parameterized on │ │ │ │ │ +the transformed child │ │ │ │ │ +282 // type. So we need to transform the child type and pass the transformed │ │ │ │ │ +child type to an inner │ │ │ │ │ +283 // template of the node transformation struct called result (see example of │ │ │ │ │ +such a specification │ │ │ │ │ +284 // further down). │ │ │ │ │ +285 using NodeTransformation = typename │ │ │ │ │ +LookupNodeTransformation>:: │ │ │ │ │ +type; │ │ │ │ │ +286 using ChildNodeTransformation = typename │ │ │ │ │ +LookupNodeTransformation>:: │ │ │ │ │ +type; │ │ │ │ │ +287 │ │ │ │ │ +288 private: │ │ │ │ │ +289 // Since every child is same type, is enough to get transformation once │ │ │ │ │ +290 using ChildTreeTransformation = TransformTree, │ │ │ │ │ +293 ChildNodeTransformation::recursive>; │ │ │ │ │ +294 │ │ │ │ │ +295 // Get transformed type of children │ │ │ │ │ +296 using transformed_child_type = typename ChildTreeTransformation:: │ │ │ │ │ +transformed_type; │ │ │ │ │ +297 using transformed_child_storage_type = typename ChildTreeTransformation:: │ │ │ │ │ +transformed_storage_type; │ │ │ │ │ +298 public: │ │ │ │ │ +299 // Apply transformation from children to current node │ │ │ │ │ +300 using transformed_type = typename NodeTransformation::template │ │ │ │ │ +result::type; │ │ │ │ │ +301 using transformed_storage_type = typename NodeTransformation::template │ │ │ │ │ +result::storage_type; │ │ │ │ │ +302 │ │ │ │ │ +303 // Transform an instance of source tree. │ │ │ │ │ +304 static transformed_type transform(const Source& source, Transformation& │ │ │ │ │ +transformation) │ │ │ │ │ +305 { │ │ │ │ │ +306 auto children_storage = node_storage_provider>(source.degree()); │ │ │ │ │ +307 for (std::size_t k = 0; k < source.degree(); ++k) { │ │ │ │ │ +308 children_storage[k] = ChildTreeTransformation::transform_storage │ │ │ │ │ +(source.childStorage(k),transformation); │ │ │ │ │ +309 } │ │ │ │ │ +310 return NodeTransformation::transform │ │ │ │ │ +(source,transformation,children_storage); │ │ │ │ │ +311 } │ │ │ │ │ +312 │ │ │ │ │ +313 // Transform an instance of source tree. │ │ │ │ │ +314 static transformed_type transform(const Source& source, const │ │ │ │ │ +Transformation& transformation) │ │ │ │ │ +315 { │ │ │ │ │ +316 auto children_storage = node_storage_provider>(source.degree()); │ │ │ │ │ +317 for (std::size_t k = 0; k < source.degree(); ++k) { │ │ │ │ │ +318 children_storage[k] = ChildTreeTransformation::transform_storage │ │ │ │ │ +(source.childStorage(k),transformation); │ │ │ │ │ +319 } │ │ │ │ │ +320 return NodeTransformation::transform │ │ │ │ │ +(source,transformation,children_storage); │ │ │ │ │ +321 } │ │ │ │ │ +322 │ │ │ │ │ +323 // Transform an instance of source tree. │ │ │ │ │ +324 static transformed_type transform(std::shared_ptr source_ptr, │ │ │ │ │ +Transformation& transformation) │ │ │ │ │ +325 { │ │ │ │ │ +326 auto children_storage = node_storage_provider>(source_ptr->degree()); │ │ │ │ │ +327 for (std::size_t k = 0; k < source_ptr->degree(); ++k) { │ │ │ │ │ +328 children_storage[k] = ChildTreeTransformation::transform_storage │ │ │ │ │ +(source_ptr->childStorage(k),transformation); │ │ │ │ │ +329 } │ │ │ │ │ +330 return NodeTransformation::transform │ │ │ │ │ +(source_ptr,transformation,children_storage); │ │ │ │ │ +331 } │ │ │ │ │ +332 │ │ │ │ │ +333 // Transform an instance of source tree. │ │ │ │ │ +334 static transformed_type transform(std::shared_ptr source_ptr, │ │ │ │ │ +const Transformation& transformation) │ │ │ │ │ +335 { │ │ │ │ │ +336 auto children_storage = node_storage_provider>(source_ptr->degree()); │ │ │ │ │ +337 for (std::size_t k = 0; k < source_ptr->degree(); ++k) { │ │ │ │ │ +338 children_storage[k] = ChildTreeTransformation::transform_storage │ │ │ │ │ +(source_ptr->childStorage(k),transformation); │ │ │ │ │ +339 } │ │ │ │ │ +340 return NodeTransformation::transform │ │ │ │ │ +(source_ptr,transformation,children_storage); │ │ │ │ │ +341 } │ │ │ │ │ +342 │ │ │ │ │ +343 // Transform an instance of source tree ptr. │ │ │ │ │ +344 static transformed_storage_type transform_storage(std::shared_ptr source_ptr, Transformation& transformation) │ │ │ │ │ +345 { │ │ │ │ │ +346 auto children_storage = │ │ │ │ │ +node_storage_provider(source_ptr->degree()); │ │ │ │ │ +347 for (std::size_t k = 0; k < source_ptr->degree(); ++k) { │ │ │ │ │ +348 children_storage[k] = ChildTreeTransformation::transform_storage │ │ │ │ │ +(source_ptr->childStorage(k),transformation); │ │ │ │ │ +349 } │ │ │ │ │ +350 return NodeTransformation::transform_storage │ │ │ │ │ +(source_ptr,transformation,children_storage); │ │ │ │ │ +351 } │ │ │ │ │ +352 │ │ │ │ │ +353 // Transform an instance of source tree ptr. │ │ │ │ │ +354 static transformed_storage_type transform_storage(std::shared_ptr source_ptr, const Transformation& transformation) │ │ │ │ │ +355 { │ │ │ │ │ +356 auto children_storage = │ │ │ │ │ +node_storage_provider(source_ptr->degree()); │ │ │ │ │ +357 for (std::size_t k = 0; k < source_ptr->degree(); ++k) { │ │ │ │ │ +358 children_storage[k] = ChildTreeTransformation::transform_storage │ │ │ │ │ +(source_ptr->childStorage(k),transformation); │ │ │ │ │ +359 } │ │ │ │ │ +360 return NodeTransformation::transform_storage │ │ │ │ │ +(source_ptr,transformation,children_storage); │ │ │ │ │ +361 } │ │ │ │ │ +362 │ │ │ │ │ +363 }; │ │ │ │ │ +364 } // namespace Impl │ │ │ │ │ +365 │ │ │ │ │ +366 // Recursive version of the PowerNode transformation for static nodes. │ │ │ │ │ +367 template │ │ │ │ │ +368 struct TransformTree │ │ │ │ │ +369 : public Impl:: │ │ │ │ │ +RecursivePowerTransformTree │ │ │ │ │ +370 {}; │ │ │ │ │ +371 │ │ │ │ │ +372 // Recursive version of the DynamicPowerNode transformation for static │ │ │ │ │ +nodes. │ │ │ │ │ +373 template │ │ │ │ │ +374 struct TransformTree │ │ │ │ │ +375 : public Impl:: │ │ │ │ │ +RecursivePowerTransformTree │ │ │ │ │ +376 {}; │ │ │ │ │ +377 │ │ │ │ │ +378 // non-recursive version of the PowerNode transformation. │ │ │ │ │ +379 template │ │ │ │ │ +380 struct TransformTree │ │ │ │ │ +381 : public TransformTreeNonRecursive │ │ │ │ │ +382 {}; │ │ │ │ │ +383 │ │ │ │ │ +384 // non-recursive version of the DynamicPowerNodeTag transformation. │ │ │ │ │ +385 template │ │ │ │ │ +386 struct TransformTree │ │ │ │ │ +387 : public TransformTreeNonRecursive │ │ │ │ │ +388 {}; │ │ │ │ │ +389 │ │ │ │ │ +390 // helper struct that does the actual transformation for a composite node. │ │ │ │ │ +We need this additional struct │ │ │ │ │ +391 // to extract the template argument list with the types of all children │ │ │ │ │ +from the node, which we cannot do │ │ │ │ │ +392 // directly in the transformation<> template, as the type passed to │ │ │ │ │ +transformation<> will usually be a │ │ │ │ │ +393 // derived type and will normally have more template arguments than just │ │ │ │ │ +the children. This declaration │ │ │ │ │ +394 // just introduces the type of the helper struct, we always instantiate the │ │ │ │ │ +specialization defined below; │ │ │ │ │ +395 template │ │ │ │ │ +396 struct transform_composite_node; │ │ │ │ │ +397 │ │ │ │ │ +398 // specialized version of the helper struct which extracts the template │ │ │ │ │ +argument list with the children from │ │ │ │ │ +399 // its second template parameter, which has to be CompositeNode:: │ │ │ │ │ +ChildTypes. Apart from that, the struct is │ │ │ │ │ +400 // similar to the one for a PowerNode, but it obviously delegates │ │ │ │ │ +transformation of the children to the TMP. │ │ │ │ │ +401 template │ │ │ │ │ +402 struct transform_composite_node,T> │ │ │ │ │ +403 { │ │ │ │ │ +404 │ │ │ │ │ +405 // transformed type, using the same nested struct trick as the PowerNode │ │ │ │ │ +406 typedef ImplementationTag Tag; │ │ │ │ │ +407 typedef typename LookupNodeTransformation::type │ │ │ │ │ +NodeTransformation; │ │ │ │ │ +408 typedef typename NodeTransformation::template _r_e_s_u_l_t, │ │ │ │ │ +411 LookupNodeTransformation>::type::recursive │ │ │ │ │ +412 >::transformed_type... │ │ │ │ │ +413 >::type transformed_type; │ │ │ │ │ +414 │ │ │ │ │ +415 typedef typename NodeTransformation::template _r_e_s_u_l_t, │ │ │ │ │ +418 LookupNodeTransformation>::type::recursive │ │ │ │ │ +419 >::transformed_type... │ │ │ │ │ +420 >::storage_type transformed_storage_type; │ │ │ │ │ +421 │ │ │ │ │ +422 // Retrieve the transformation descriptor for the child with index i. │ │ │ │ │ +423 // This little helper improves really improves the readability of the │ │ │ │ │ +424 // transformation functions. │ │ │ │ │ +425 template │ │ │ │ │ +426 struct ChildTransformation │ │ │ │ │ +427 : public TransformTree::Type, │ │ │ │ │ +428 T, │ │ │ │ │ +429 NodeTag::Type>, │ │ │ │ │ +430 LookupNodeTransformation< │ │ │ │ │ +431 typename S::template Child::Type, │ │ │ │ │ +432 T, │ │ │ │ │ +433 ImplementationTag::Type> │ │ │ │ │ +434 >::type::recursive │ │ │ │ │ +435 > │ │ │ │ │ +436 {}; │ │ │ │ │ +437 │ │ │ │ │ +438 template │ │ │ │ │ +439 static void setElement(Tuple& tuple, Value&& value) │ │ │ │ │ +440 { │ │ │ │ │ +441 std::get(tuple) = std::forward(value); │ │ │ │ │ +442 } │ │ │ │ │ +443 │ │ │ │ │ +444 template │ │ │ │ │ +445 static transformed_type transform(const S& s, Trafo&& t, std:: │ │ │ │ │ +index_sequence indices) │ │ │ │ │ +446 { │ │ │ │ │ +447 std::tuple::transformed_storage_type...> │ │ │ │ │ +storage; │ │ │ │ │ +448 Dune::Hybrid::Impl::evaluateFoldExpression({(setElement(storage, │ │ │ │ │ +ChildTransformation::transform_storage(s.template childStorage(), std:: │ │ │ │ │ +forward(t))),0)...}); │ │ │ │ │ +449 return NodeTransformation::transform(s, std::forward(t), std::get │ │ │ │ │ +(storage)...); │ │ │ │ │ +450 } │ │ │ │ │ +451 │ │ │ │ │ +452 template │ │ │ │ │ +453 static transformed_storage_type transform_storage(std::shared_ptr │ │ │ │ │ +sp, Trafo&& t, std::index_sequence indices) │ │ │ │ │ +454 { │ │ │ │ │ +455 std::tuple::transformed_storage_type...> │ │ │ │ │ +storage; │ │ │ │ │ +456 Dune::Hybrid::Impl::evaluateFoldExpression({(setElement(storage, │ │ │ │ │ +ChildTransformation::transform_storage(sp->template childStorage(), std:: │ │ │ │ │ +forward(t))),0)...}); │ │ │ │ │ +457 return NodeTransformation::transform_storage(sp, std::forward(t), │ │ │ │ │ +std::get(storage)...); │ │ │ │ │ +458 } │ │ │ │ │ +459 }; │ │ │ │ │ +460 │ │ │ │ │ +461 │ │ │ │ │ +462 // the specialization of transformation<> for the CompositeNode. This just │ │ │ │ │ +extracts the │ │ │ │ │ +463 // CompositeNode::ChildTypes member and forwards to the helper struct │ │ │ │ │ +464 template │ │ │ │ │ +465 struct TransformTree │ │ │ │ │ +466 { │ │ │ │ │ +467 │ │ │ │ │ +468 private: │ │ │ │ │ +469 │ │ │ │ │ +470 typedef typename S::ChildTypes ChildTypes; │ │ │ │ │ +471 │ │ │ │ │ +472 static auto child_indices() │ │ │ │ │ +473 { │ │ │ │ │ +474 return std::make_index_sequence(); │ │ │ │ │ +475 } │ │ │ │ │ +476 │ │ │ │ │ +477 public: │ │ │ │ │ +478 │ │ │ │ │ +479 typedef typename transform_composite_node::transformed_type │ │ │ │ │ +transformed_type; │ │ │ │ │ +480 typedef typename transform_composite_node:: │ │ │ │ │ +transformed_storage_type transformed_storage_type; │ │ │ │ │ +481 │ │ │ │ │ +482 static transformed_type _t_r_a_n_s_f_o_r_m(const S& s, T& t) │ │ │ │ │ +483 { │ │ │ │ │ +484 return transform_composite_node::transform │ │ │ │ │ +(s,t,child_indices()); │ │ │ │ │ +485 } │ │ │ │ │ +486 │ │ │ │ │ +487 static transformed_type _t_r_a_n_s_f_o_r_m(const S& s, const T& t) │ │ │ │ │ +488 { │ │ │ │ │ +489 return transform_composite_node::transform │ │ │ │ │ +(s,t,child_indices()); │ │ │ │ │ +490 } │ │ │ │ │ +491 │ │ │ │ │ +492 static transformed_storage_type _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std::shared_ptr │ │ │ │ │ +sp, T& t) │ │ │ │ │ +493 { │ │ │ │ │ +494 return transform_composite_node::transform_storage │ │ │ │ │ +(sp,t,child_indices()); │ │ │ │ │ +495 } │ │ │ │ │ +496 │ │ │ │ │ +497 static transformed_storage_type _t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e(std::shared_ptr │ │ │ │ │ +sp, const T& t) │ │ │ │ │ +498 { │ │ │ │ │ +499 return transform_composite_node::transform_storage │ │ │ │ │ +(sp,t,child_indices()); │ │ │ │ │ +500 } │ │ │ │ │ +501 │ │ │ │ │ +502 }; │ │ │ │ │ +503 │ │ │ │ │ +504 // non-recursive version of the CompositeNode transformation. │ │ │ │ │ +505 template │ │ │ │ │ +506 struct TransformTree │ │ │ │ │ +507 : public TransformTreeNonRecursive │ │ │ │ │ +508 {}; │ │ │ │ │ +509 │ │ │ │ │ +510#endif // DOXYGEN │ │ │ │ │ +511 │ │ │ │ │ +513 │ │ │ │ │ +514 } // namespace TypeTree │ │ │ │ │ +515} //namespace Dune │ │ │ │ │ +516 │ │ │ │ │ +517#endif // DUNE_TYPETREE_TRANSFORMATION_HH │ │ │ │ │ _t_y_p_e_t_r_a_i_t_s_._h_h │ │ │ │ │ +_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_t_a_g_s_._h_h │ │ │ │ │ +_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_r_e_g_i_s_t_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n │ │ │ │ │ +void registerNodeTransformation(SourceNode *, Transformation *, Tag *) │ │ │ │ │ +Register transformation descriptor to transform SourceNode with Transformation. │ │ │ │ │ _D_u_n_e │ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e │ │ │ │ │ -Collect multiple instances of type T within a dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:35 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_i_s_P_o_w_e_r │ │ │ │ │ -static const bool isPower │ │ │ │ │ -Mark this class as a power in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:43 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ -std::vector< ChildStorageType > NodeStorage │ │ │ │ │ -The type used for storing the children. │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:67 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_n_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ -const NodeStorage & nodeStorage() const │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:137 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ -ChildConstStorageType childStorage(std::size_t i) const │ │ │ │ │ -Returns the storage of the i-th child (const version). │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:110 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ -const ChildType & child(std::size_t i) const │ │ │ │ │ -Returns the i-th child (const version). │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:87 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_C_h_i_l_d_S_t_o_r_a_g_e_T_y_p_e │ │ │ │ │ -std::shared_ptr< T > ChildStorageType │ │ │ │ │ -The storage type of each child. │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:61 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e │ │ │ │ │ -DynamicPowerNode(T &t1, T &t2,...) │ │ │ │ │ -Initialize all children with the passed-in objects. │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:174 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_C_h_i_l_d_C_o_n_s_t_S_t_o_r_a_g_e_T_y_p_e │ │ │ │ │ -std::shared_ptr< const T > ChildConstStorageType │ │ │ │ │ -The const version of the storage type of each child. │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:64 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e │ │ │ │ │ -DynamicPowerNode(NodeStorage children) │ │ │ │ │ -Initialize the DynamicPowerNode with a copy of the passed-in storage type. │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:167 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_N_o_d_e_T_a_g │ │ │ │ │ -DynamicPowerNodeTag NodeTag │ │ │ │ │ -The type tag that describes the node. │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:55 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_C_h_i_l_d_T_y_p_e │ │ │ │ │ -T ChildType │ │ │ │ │ -The type of each child. │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:58 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ -void setChild(std::size_t i, ChildType &t) │ │ │ │ │ -Sets the i-th child to the passed-in value. │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:117 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ -void setChild(std::size_t i, ChildStorageType st) │ │ │ │ │ -Sets the stored value representing the i-th child to the passed-in value. │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:131 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e │ │ │ │ │ -DynamicPowerNode(std::size_t size) │ │ │ │ │ -Construct a node with the given number of children. │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:162 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_i_s_C_o_m_p_o_s_i_t_e │ │ │ │ │ -static const bool isComposite │ │ │ │ │ -Mark this class as a non composite in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:46 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ -void setChild(std::size_t i, ChildType &&t) │ │ │ │ │ -Store the passed value in i-th child. │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:124 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ -ChildType & child(std::size_t i) │ │ │ │ │ -Returns the i-th child. │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:77 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_d_e_g_r_e_e │ │ │ │ │ -std::size_t degree() const │ │ │ │ │ -The number of children. │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:49 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ -ChildStorageType childStorage(std::size_t i) │ │ │ │ │ -Returns the storage of the i-th child. │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:97 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_i_s_L_e_a_f │ │ │ │ │ -static const bool isLeaf │ │ │ │ │ -Mark this class as non leaf in the dune-typetree. │ │ │ │ │ -DDeeffiinniittiioonn dynamicpowernode.hh:40 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e │ │ │ │ │ -DynamicPowerNode()=delete │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g │ │ │ │ │ -Tag designating a power node with runtime degree. │ │ │ │ │ -DDeeffiinniittiioonn nodetags.hh:24 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e │ │ │ │ │ +Transform a TypeTree. │ │ │ │ │ +DDeeffiinniittiioonn transformation.hh:96 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e_:_:_T_y_p_e │ │ │ │ │ +type Type │ │ │ │ │ +DDeeffiinniittiioonn transformation.hh:113 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ +static transformed_type transform(std::shared_ptr< const SourceTree > sp, │ │ │ │ │ +Transformation &t) │ │ │ │ │ +Apply transformation to an existing tree s. │ │ │ │ │ +DDeeffiinniittiioonn transformation.hh:134 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ +static transformed_type transform(std::shared_ptr< const SourceTree > sp, const │ │ │ │ │ +Transformation &t=Transformation()) │ │ │ │ │ +Apply transformation to an existing tree s. │ │ │ │ │ +DDeeffiinniittiioonn transformation.hh:128 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ +static transformed_type transform(const SourceTree &s, Transformation &t) │ │ │ │ │ +Apply transformation to an existing tree s. │ │ │ │ │ +DDeeffiinniittiioonn transformation.hh:122 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e_:_:_t_y_p_e │ │ │ │ │ +transformed_type type │ │ │ │ │ +The type of the transformed tree. │ │ │ │ │ +DDeeffiinniittiioonn transformation.hh:111 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e_:_:_t_r_a_n_s_f_o_r_m │ │ │ │ │ +static transformed_type transform(const SourceTree &s, const Transformation │ │ │ │ │ +&t=Transformation()) │ │ │ │ │ +Apply transformation to an existing tree s. │ │ │ │ │ +DDeeffiinniittiioonn transformation.hh:116 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ +static transformed_storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ +SourceTree > sp, const Transformation &t=Transformation()) │ │ │ │ │ +DDeeffiinniittiioonn transformation.hh:141 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_T_r_a_n_s_f_o_r_m_T_r_e_e_:_:_t_r_a_n_s_f_o_r_m___s_t_o_r_a_g_e │ │ │ │ │ +static transformed_storage_type transform_storage(std::shared_ptr< const │ │ │ │ │ +SourceTree > sp, Transformation &t) │ │ │ │ │ +DDeeffiinniittiioonn transformation.hh:148 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_e_v_a_l_u_a_t_e___i_f___m_e_t_a___f_u_n_c_t_i_o_n │ │ │ │ │ +Meta function that evaluates its argument iff it inherits from meta_function. │ │ │ │ │ +DDeeffiinniittiioonn typetraits.hh:142 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00080.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: traversal.hh File Reference │ │ │ │ +dune-typetree: proxynode.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -70,78 +70,61 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -Namespaces | │ │ │ │ -Typedefs | │ │ │ │ -Functions
    │ │ │ │ -
    traversal.hh File Reference
    │ │ │ │ +Classes | │ │ │ │ +Namespaces
    │ │ │ │ +
    proxynode.hh File Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ -
    #include <utility>
    │ │ │ │ -#include <dune/common/hybridutilities.hh>
    │ │ │ │ +
    #include <type_traits>
    │ │ │ │ +#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ +#include <dune/typetree/nodetags.hh>
    │ │ │ │ +#include <dune/common/shared_ptr.hh>
    │ │ │ │ +#include <dune/common/indices.hh>
    │ │ │ │ #include <dune/common/std/type_traits.hh>
    │ │ │ │ -#include <dune/typetree/childextraction.hh>
    │ │ │ │ -#include <dune/typetree/nodetags.hh>
    │ │ │ │ -#include <dune/typetree/treepath.hh>
    │ │ │ │ -#include <dune/typetree/visitor.hh>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │ │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ +

    │ │ │ │ +Classes

    class  Dune::TypeTree::StaticChildAccessors< ProxiedNode >
     Mixin class providing methods for child access with compile-time parameter. More...
     
    struct  Dune::TypeTree::StaticChildAccessors< ProxiedNode >::Child< k >
     Access to the type and storage type of the i-th child. More...
     
    class  Dune::TypeTree::DynamicChildAccessors< ProxiedNode >
     Mixin class providing methods for child access with run-time parameter. More...
     
    struct  Dune::TypeTree::ProxyNodeBase< Node, LeafNodeTag >
     ProxyNode base class for LeafNode. More...
     
    struct  Dune::TypeTree::ProxyNodeBase< Node, CompositeNodeTag >
     ProxyNode base class for CompositeNode. More...
     
    struct  Dune::TypeTree::ProxyNodeBase< Node, PowerNodeTag >
     ProxyNode base class for PowerNode. More...
     
    struct  Dune::TypeTree::ProxyNodeBase< Node, DynamicPowerNodeTag >
     ProxyNode base class for DynamicPowerNode. More...
     
    class  Dune::TypeTree::ProxyNode< Node >
     Base class for nodes acting as a proxy for an existing node. More...
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ -

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
     
    namespace  Dune::TypeTree::Detail
     
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -

    │ │ │ │ -Typedefs

    template<class Tree >
    using Dune::TypeTree::Detail::DynamicTraversalConcept = decltype((std::declval< Tree >().degree(), std::declval< Tree >().child(0u)))
     
    template<class Tree >
    using Dune::TypeTree::Detail::StaticTraversalConcept = decltype((std::integral_constant< std::size_t, Tree::degree()>{}))
     
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │

    │ │ │ │ -Functions

    template<class Tree , TreePathType::Type pathType, class Prefix , std::enable_if_t< Tree::isLeaf, int > = 0>
    constexpr auto Dune::TypeTree::Detail::leafTreePathTuple (Prefix prefix)
     
    template<class Tree , TreePathType::Type pathType, class Prefix , std::size_t... indices, std::enable_if_t<(Tree::isComposite or(Tree::isPower and(pathType!=TreePathType::dynamic))), int > = 0>
    constexpr auto Dune::TypeTree::Detail::leafTreePathTuple (Prefix prefix, std::index_sequence< indices... >)
     
    template<class T , class TreePath , class V , std::enable_if_t< std::decay_t< T >::isLeaf, int > = 0>
    void Dune::TypeTree::Detail::applyToTree (T &&tree, TreePath treePath, V &&visitor)
     
    template<class T , class TreePath , class PreFunc , class LeafFunc , class PostFunc >
    void Dune::TypeTree::Detail::forEachNode (T &&tree, TreePath treePath, PreFunc &&preFunc, LeafFunc &&leafFunc, PostFunc &&postFunc)
     
    template<class Tree , TreePathType::Type pathType = TreePathType::dynamic>
    constexpr auto Dune::TypeTree::leafTreePathTuple ()
     Create tuple of tree paths to leafs.
     
    template<typename Tree , typename Visitor >
    void Dune::TypeTree::applyToTree (Tree &&tree, Visitor &&visitor)
     Apply visitor to TypeTree.
     
    template<class Tree , class NodeFunc >
    void Dune::TypeTree::forEachNode (Tree &&tree, NodeFunc &&nodeFunc)
     Traverse tree and visit each node.
     
    template<class Tree , class LeafFunc >
    void Dune::TypeTree::forEachLeafNode (Tree &&tree, LeafFunc &&leafFunc)
     Traverse tree and visit each leaf node.
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,73 +1,49 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -_N_a_m_e_s_p_a_c_e_s | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s │ │ │ │ │ -traversal.hh File Reference │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include │ │ │ │ │ -#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h> │ │ │ │ │ +_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s │ │ │ │ │ +proxynode.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_/_v_i_s_i_t_o_r_._h_h> │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ _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 │ │ │ │ │ + class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_<_ _P_r_o_x_i_e_d_N_o_d_e_ _> │ │ │ │ │ +  Mixin class providing methods for child access with compile-time │ │ │ │ │ + parameter. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_<_ _P_r_o_x_i_e_d_N_o_d_e_ _>_:_:_C_h_i_l_d_<_ _k_ _> │ │ │ │ │ +  Access to the type and storage type of the i-th child. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ + class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_<_ _P_r_o_x_i_e_d_N_o_d_e_ _> │ │ │ │ │ +  Mixin class providing methods for child access with run-time │ │ │ │ │ + parameter. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _L_e_a_f_N_o_d_e_T_a_g_ _> │ │ │ │ │ +  _P_r_o_x_y_N_o_d_e base class for _L_e_a_f_N_o_d_e. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g_ _> │ │ │ │ │ +  _P_r_o_x_y_N_o_d_e base class for _C_o_m_p_o_s_i_t_e_N_o_d_e. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _P_o_w_e_r_N_o_d_e_T_a_g_ _> │ │ │ │ │ +  _P_r_o_x_y_N_o_d_e base class for _P_o_w_e_r_N_o_d_e. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g_ _> │ │ │ │ │ +  _P_r_o_x_y_N_o_d_e base class for _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ + class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_<_ _N_o_d_e_ _> │ │ │ │ │ +  Base class for nodes acting as a proxy for an existing node. _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_:_:_D_e_t_a_i_l │ │ │ │ │ -  │ │ │ │ │ -TTyyppeeddeeffss │ │ │ │ │ -template │ │ │ │ │ -using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_D_y_n_a_m_i_c_T_r_a_v_e_r_s_a_l_C_o_n_c_e_p_t = decltype((std:: │ │ │ │ │ - declval< Tree >()._d_e_g_r_e_e(), std::declval< Tree >()._c_h_i_l_d(0u))) │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ -using  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_S_t_a_t_i_c_T_r_a_v_e_r_s_a_l_C_o_n_c_e_p_t = decltype((std:: │ │ │ │ │ - integral_constant< std::size_t, Tree::degree()>{})) │ │ │ │ │ -  │ │ │ │ │ -FFuunnccttiioonnss │ │ │ │ │ -template = 0> │ │ │ │ │ -constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e (Prefix prefix) │ │ │ │ │ -  │ │ │ │ │ -template = 0> │ │ │ │ │ -constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e (Prefix prefix, std:: │ │ │ │ │ - index_sequence< indices... >) │ │ │ │ │ -  │ │ │ │ │ -template::isLeaf, int > = 0> │ │ │ │ │ - void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_a_p_p_l_y_T_o_T_r_e_e (T &&tree, TreePath │ │ │ │ │ - _t_r_e_e_P_a_t_h, V &&visitor) │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_f_o_r_E_a_c_h_N_o_d_e (T &&tree, TreePath │ │ │ │ │ - _t_r_e_e_P_a_t_h, PreFunc &&preFunc, LeafFunc &&leafFunc, PostFunc │ │ │ │ │ - &&postFunc) │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ -constexpr auto  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e () │ │ │ │ │ -  Create tuple of tree paths to leafs. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_a_p_p_l_y_T_o_T_r_e_e (Tree &&tree, Visitor &&visitor) │ │ │ │ │ -  Apply visitor to _T_y_p_e_T_r_e_e. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_o_r_E_a_c_h_N_o_d_e (Tree &&tree, NodeFunc &&nodeFunc) │ │ │ │ │ -  Traverse tree and visit each node. │ │ │ │ │ -  │ │ │ │ │ -template │ │ │ │ │ - void  _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_o_r_E_a_c_h_L_e_a_f_N_o_d_e (Tree &&tree, LeafFunc │ │ │ │ │ - &&leafFunc) │ │ │ │ │ -  Traverse tree and visit each leaf node. │ │ │ │ │ -  │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00080_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: traversal.hh Source File │ │ │ │ +dune-typetree: proxynode.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,281 +74,397 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -
    traversal.hh
    │ │ │ │ +
    proxynode.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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_TRAVERSAL_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_TRAVERSAL_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_PROXYNODE_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_PROXYNODE_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <utility>
    │ │ │ │ -
    10
    │ │ │ │ -
    11#include <dune/common/hybridutilities.hh>
    │ │ │ │ -
    12#include <dune/common/std/type_traits.hh>
    │ │ │ │ -
    13
    │ │ │ │ -
    14#include <dune/typetree/childextraction.hh>
    │ │ │ │ -
    15#include <dune/typetree/nodetags.hh>
    │ │ │ │ -
    16#include <dune/typetree/treepath.hh>
    │ │ │ │ -
    17#include <dune/typetree/visitor.hh>
    │ │ │ │ +
    9#include <type_traits>
    │ │ │ │ +
    10#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ +
    11#include <dune/typetree/nodetags.hh>
    │ │ │ │ +
    12#include <dune/common/shared_ptr.hh>
    │ │ │ │ +
    13#include <dune/common/indices.hh>
    │ │ │ │ +
    14#include <dune/common/std/type_traits.hh>
    │ │ │ │ +
    15
    │ │ │ │ +
    16namespace Dune {
    │ │ │ │ +
    17 namespace TypeTree {
    │ │ │ │
    18
    │ │ │ │ -
    19namespace Dune {
    │ │ │ │ -
    20 namespace TypeTree {
    │ │ │ │ -
    21
    │ │ │ │ -
    27#ifndef DOXYGEN
    │ │ │ │ -
    29 struct NoOp
    │ │ │ │ +
    24 template<typename Node>
    │ │ │ │ +
    25 class ProxyNode;
    │ │ │ │ +
    26
    │ │ │ │ +
    28 template<typename ProxiedNode>
    │ │ │ │ +
    │ │ │ │ +
    29 class StaticChildAccessors
    │ │ │ │
    30 {
    │ │ │ │ -
    31 template<class... T>
    │ │ │ │ -
    32 constexpr void operator()(T&&...) const { /* do nothing */ }
    │ │ │ │ -
    33 };
    │ │ │ │ -
    34#endif
    │ │ │ │ -
    35
    │ │ │ │ -
    36 namespace Detail {
    │ │ │ │ -
    37
    │ │ │ │ -
    38 // SFINAE template check that Tree has a degree() function and a child() function accepting integer indices
    │ │ │ │ -
    39 template<class Tree>
    │ │ │ │ -
    40 using DynamicTraversalConcept = decltype((
    │ │ │ │ -
    41 std::declval<Tree>().degree(),
    │ │ │ │ -
    42 std::declval<Tree>().child(0u)
    │ │ │ │ -
    43 ));
    │ │ │ │ -
    44
    │ │ │ │ -
    45 // SFINAE template check that Tree has static (constexpr) function Tree::degree()
    │ │ │ │ -
    46 template<class Tree>
    │ │ │ │ -
    47 using StaticTraversalConcept = decltype((
    │ │ │ │ -
    48 std::integral_constant<std::size_t, Tree::degree()>{}
    │ │ │ │ -
    49 ));
    │ │ │ │ -
    50
    │ │ │ │ -
    51
    │ │ │ │ -
    52 template<class Tree, TreePathType::Type pathType, class Prefix,
    │ │ │ │ -
    53 std::enable_if_t<Tree::isLeaf, int> = 0>
    │ │ │ │ -
    │ │ │ │ -
    54 constexpr auto leafTreePathTuple(Prefix prefix)
    │ │ │ │ -
    55 {
    │ │ │ │ -
    56 return std::make_tuple(prefix);
    │ │ │ │ -
    57 }
    │ │ │ │ -
    │ │ │ │ -
    58
    │ │ │ │ -
    59 template<class Tree, TreePathType::Type pathType, class Prefix,
    │ │ │ │ -
    60 std::enable_if_t<not Tree::isLeaf, int> = 0>
    │ │ │ │ -
    61 constexpr auto leafTreePathTuple(Prefix prefix);
    │ │ │ │ -
    62
    │ │ │ │ -
    63 template<class Tree, TreePathType::Type pathType, class Prefix, std::size_t... indices,
    │ │ │ │ -
    64 std::enable_if_t<(Tree::isComposite or (Tree::isPower and (pathType!=TreePathType::dynamic))), int> = 0>
    │ │ │ │ -
    │ │ │ │ -
    65 constexpr auto leafTreePathTuple(Prefix prefix, std::index_sequence<indices...>)
    │ │ │ │ -
    66 {
    │ │ │ │ -
    67 return std::tuple_cat(Detail::leafTreePathTuple<TypeTree::Child<Tree,indices>, pathType>(Dune::TypeTree::push_back(prefix, Dune::index_constant<indices>{}))...);
    │ │ │ │ -
    68 }
    │ │ │ │ -
    │ │ │ │ -
    69
    │ │ │ │ -
    70 template<class Tree, TreePathType::Type pathType, class Prefix, std::size_t... indices,
    │ │ │ │ -
    71 std::enable_if_t<(Tree::isPower and (pathType==TreePathType::dynamic)), int> = 0>
    │ │ │ │ -
    72 constexpr auto leafTreePathTuple(Prefix prefix, std::index_sequence<indices...>)
    │ │ │ │ -
    73 {
    │ │ │ │ -
    74 return std::tuple_cat(Detail::leafTreePathTuple<TypeTree::Child<Tree,indices>, pathType>(Dune::TypeTree::push_back(prefix, indices))...);
    │ │ │ │ -
    75 }
    │ │ │ │ -
    76
    │ │ │ │ -
    77 template<class Tree, TreePathType::Type pathType, class Prefix,
    │ │ │ │ -
    78 std::enable_if_t<not Tree::isLeaf, int>>
    │ │ │ │ -
    79 constexpr auto leafTreePathTuple(Prefix prefix)
    │ │ │ │ -
    80 {
    │ │ │ │ -
    81 return Detail::leafTreePathTuple<Tree, pathType>(prefix, std::make_index_sequence<Tree::degree()>{});
    │ │ │ │ -
    82 }
    │ │ │ │ -
    83
    │ │ │ │ -
    84 /* The signature is the same as for the public applyToTree
    │ │ │ │ -
    85 * function in Dune::Typetree, despite the additionally passed
    │ │ │ │ -
    86 * treePath argument. The path passed here is associated to
    │ │ │ │ -
    87 * the tree and the relative paths of the children (wrt. to tree)
    │ │ │ │ -
    88 * are appended to this. Hence the behavior of the public function
    │ │ │ │ -
    89 * is resembled by passing an empty treePath.
    │ │ │ │ -
    90 */
    │ │ │ │ -
    91
    │ │ │ │ -
    92 /*
    │ │ │ │ -
    93 * This is the overload for leaf traversal
    │ │ │ │ -
    94 */
    │ │ │ │ -
    95 template<class T, class TreePath, class V,
    │ │ │ │ -
    96 std::enable_if_t<std::decay_t<T>::isLeaf, int> = 0>
    │ │ │ │ -
    │ │ │ │ -
    97 void applyToTree(T&& tree, TreePath treePath, V&& visitor)
    │ │ │ │ -
    98 {
    │ │ │ │ -
    99 visitor.leaf(tree, treePath);
    │ │ │ │ -
    100 }
    │ │ │ │ -
    │ │ │ │ -
    101
    │ │ │ │ -
    102 /*
    │ │ │ │ -
    103 * This is the general overload doing child traversal.
    │ │ │ │ -
    104 */
    │ │ │ │ -
    105 template<class T, class TreePath, class V,
    │ │ │ │ -
    106 std::enable_if_t<not std::decay_t<T>::isLeaf, int> = 0>
    │ │ │ │ -
    107 void applyToTree(T&& tree, TreePath treePath, V&& visitor)
    │ │ │ │ -
    108 {
    │ │ │ │ -
    109 using Tree = std::remove_reference_t<T>;
    │ │ │ │ -
    110 using Visitor = std::remove_reference_t<V>;
    │ │ │ │ -
    111 visitor.pre(tree, treePath);
    │ │ │ │ -
    112
    │ │ │ │ -
    113 // check which type of traversal is supported by the tree
    │ │ │ │ -
    114 using allowDynamicTraversal = Dune::Std::is_detected<DynamicTraversalConcept,Tree>;
    │ │ │ │ -
    115 using allowStaticTraversal = Dune::Std::is_detected<StaticTraversalConcept,Tree>;
    │ │ │ │ +
    31
    │ │ │ │ +
    32 static const bool proxiedNodeIsConst = std::is_const<typename std::remove_reference<ProxiedNode>::type>::value;
    │ │ │ │ +
    33
    │ │ │ │ +
    34 template<std::size_t k>
    │ │ │ │ +
    35 struct lazy_enabled
    │ │ │ │ +
    36 {
    │ │ │ │ +
    37 static const bool value = !proxiedNodeIsConst;
    │ │ │ │ +
    38 };
    │ │ │ │ +
    39
    │ │ │ │ +
    40 typedef ProxyNode<ProxiedNode> Node;
    │ │ │ │ +
    41
    │ │ │ │ +
    42 template<bool enabled = !proxiedNodeIsConst>
    │ │ │ │ +
    43 typename std::enable_if<enabled,Node&>::type
    │ │ │ │ +
    44 node ()
    │ │ │ │ +
    45 {
    │ │ │ │ +
    46 return static_cast<Node&>(*this);
    │ │ │ │ +
    47 }
    │ │ │ │ +
    48
    │ │ │ │ +
    49 const Node& node () const
    │ │ │ │ +
    50 {
    │ │ │ │ +
    51 return static_cast<const Node&>(*this);
    │ │ │ │ +
    52 }
    │ │ │ │ +
    53
    │ │ │ │ +
    54 public:
    │ │ │ │ +
    55
    │ │ │ │ +
    57 template<std::size_t k>
    │ │ │ │ +
    │ │ │ │ +
    58 struct Child
    │ │ │ │ +
    59 : public ProxiedNode::template Child<k>
    │ │ │ │ +
    60 {};
    │ │ │ │ +
    │ │ │ │ +
    61
    │ │ │ │ +
    64
    │ │ │ │ +
    66
    │ │ │ │ +
    69 template<std::size_t k,
    │ │ │ │ +
    70 typename std::enable_if<lazy_enabled<k>::value, int>::type = 0>
    │ │ │ │ +
    │ │ │ │ +
    71 auto& child (index_constant<k> = {})
    │ │ │ │ +
    72 {
    │ │ │ │ +
    73 return node().proxiedNode().template child<k>();
    │ │ │ │ +
    74 }
    │ │ │ │ +
    │ │ │ │ +
    75
    │ │ │ │ +
    77
    │ │ │ │ +
    80 template<std::size_t k>
    │ │ │ │ +
    │ │ │ │ +
    81 const auto& child (index_constant<k> = {}) const
    │ │ │ │ +
    82 {
    │ │ │ │ +
    83 return node().proxiedNode().template child<k>();
    │ │ │ │ +
    84 }
    │ │ │ │ +
    │ │ │ │ +
    85
    │ │ │ │ +
    87
    │ │ │ │ +
    90 template<std::size_t k,
    │ │ │ │ +
    91 typename std::enable_if<lazy_enabled<k>::value, int>::type = 0>
    │ │ │ │ +
    │ │ │ │ +
    92 auto childStorage (index_constant<k> = {})
    │ │ │ │ +
    93 {
    │ │ │ │ +
    94 return node().proxiedNode().template childStorage<k>();
    │ │ │ │ +
    95 }
    │ │ │ │ +
    │ │ │ │ +
    96
    │ │ │ │ +
    98
    │ │ │ │ +
    104 template<std::size_t k>
    │ │ │ │ +
    │ │ │ │ +
    105 auto childStorage (index_constant<k> = {}) const
    │ │ │ │ +
    106 {
    │ │ │ │ +
    107 return node().proxiedNode().template childStorage<k>();
    │ │ │ │ +
    108 }
    │ │ │ │ +
    │ │ │ │ +
    109
    │ │ │ │ +
    111 template<std::size_t k, class ProxyChild>
    │ │ │ │ +
    │ │ │ │ +
    112 void setChild (ProxyChild&& child, typename std::enable_if<lazy_enabled<k>::value,void*>::type = 0)
    │ │ │ │ +
    113 {
    │ │ │ │ +
    114 node().proxiedNode().template setChild<k>(std::forward<ProxyChild>(child));
    │ │ │ │ +
    115 }
    │ │ │ │ +
    │ │ │ │
    116
    │ │ │ │ -
    117 // the tree must support either dynamic or static traversal
    │ │ │ │ -
    118 static_assert(allowDynamicTraversal::value || allowStaticTraversal::value);
    │ │ │ │ -
    119
    │ │ │ │ -
    120 // the visitor may specify preferred dynamic traversal
    │ │ │ │ -
    121 using preferDynamicTraversal = std::bool_constant<Visitor::treePathType == TreePathType::dynamic>;
    │ │ │ │ -
    122
    │ │ │ │ -
    123 // create a dynamic or static index range
    │ │ │ │ -
    124 auto indices = [&]{
    │ │ │ │ -
    125 if constexpr(preferDynamicTraversal::value && allowDynamicTraversal::value)
    │ │ │ │ -
    126 return Dune::range(std::size_t(tree.degree()));
    │ │ │ │ -
    127 else
    │ │ │ │ -
    128 return Dune::range(tree.degree());
    │ │ │ │ -
    129 }();
    │ │ │ │ -
    130
    │ │ │ │ -
    131 if constexpr(allowDynamicTraversal::value || allowStaticTraversal::value) {
    │ │ │ │ -
    132 Hybrid::forEach(indices, [&](auto i) {
    │ │ │ │ -
    133 auto&& child = tree.child(i);
    │ │ │ │ -
    134 using Child = std::decay_t<decltype(child)>;
    │ │ │ │ -
    135
    │ │ │ │ -
    136 visitor.beforeChild(tree, child, treePath, i);
    │ │ │ │ -
    137
    │ │ │ │ -
    138 // This requires that visitor.in(...) can always be instantiated,
    │ │ │ │ -
    139 // even if there's a single child only.
    │ │ │ │ -
    140 if (i>0)
    │ │ │ │ -
    141 visitor.in(tree, treePath);
    │ │ │ │ -
    142
    │ │ │ │ -
    143 constexpr bool visitChild = Visitor::template VisitChild<Tree,Child,TreePath>::value;
    │ │ │ │ -
    144 if constexpr(visitChild) {
    │ │ │ │ -
    145 auto childTreePath = Dune::TypeTree::push_back(treePath, i);
    │ │ │ │ -
    146 applyToTree(child, childTreePath, visitor);
    │ │ │ │ -
    147 }
    │ │ │ │ -
    148
    │ │ │ │ -
    149 visitor.afterChild(tree, child, treePath, i);
    │ │ │ │ -
    150 });
    │ │ │ │ -
    151 }
    │ │ │ │ -
    152 visitor.post(tree, treePath);
    │ │ │ │ -
    153 }
    │ │ │ │ -
    154
    │ │ │ │ -
    155 /* Traverse tree and visit each node. The signature is the same
    │ │ │ │ -
    156 * as for the public forEachNode function in Dune::Typtree,
    │ │ │ │ -
    157 * despite the additionally passed treePath argument. The path
    │ │ │ │ -
    158 * passed here is associated to the tree and the relative
    │ │ │ │ -
    159 * paths of the children (wrt. to tree) are appended to this.
    │ │ │ │ -
    160 * Hence the behavior of the public function is resembled
    │ │ │ │ -
    161 * by passing an empty treePath.
    │ │ │ │ -
    162 */
    │ │ │ │ -
    163 template<class T, class TreePath, class PreFunc, class LeafFunc, class PostFunc>
    │ │ │ │ -
    │ │ │ │ -
    164 void forEachNode(T&& tree, TreePath treePath, PreFunc&& preFunc, LeafFunc&& leafFunc, PostFunc&& postFunc)
    │ │ │ │ -
    165 {
    │ │ │ │ -
    166 using Tree = std::decay_t<T>;
    │ │ │ │ -
    167 if constexpr(Tree::isLeaf) {
    │ │ │ │ -
    168 leafFunc(tree, treePath);
    │ │ │ │ -
    169 } else {
    │ │ │ │ -
    170 preFunc(tree, treePath);
    │ │ │ │ -
    171
    │ │ │ │ -
    172 // check which type of traversal is supported by the tree, prefer dynamic traversal
    │ │ │ │ -
    173 using allowDynamicTraversal = Dune::Std::is_detected<DynamicTraversalConcept,Tree>;
    │ │ │ │ -
    174 using allowStaticTraversal = Dune::Std::is_detected<StaticTraversalConcept,Tree>;
    │ │ │ │ +
    │ │ │ │ +
    117 const typename ProxiedNode::NodeStorage& nodeStorage () const
    │ │ │ │ +
    118 {
    │ │ │ │ +
    119 return node().proxiedNode().nodeStorage();
    │ │ │ │ +
    120 }
    │ │ │ │ +
    │ │ │ │ +
    121
    │ │ │ │ +
    122 };
    │ │ │ │ +
    │ │ │ │ +
    123
    │ │ │ │ +
    125
    │ │ │ │ +
    130 template<typename ProxiedNode>
    │ │ │ │ +
    │ │ │ │ +
    131 class DynamicChildAccessors
    │ │ │ │ +
    132 : public StaticChildAccessors<ProxiedNode>
    │ │ │ │ +
    133 {
    │ │ │ │ +
    134
    │ │ │ │ +
    135 typedef ProxyNode<ProxiedNode> Node;
    │ │ │ │ +
    136
    │ │ │ │ +
    137 static const bool proxiedNodeIsConst = std::is_const<typename std::remove_reference<ProxiedNode>::type>::value;
    │ │ │ │ +
    138
    │ │ │ │ +
    139 template<bool enabled = !proxiedNodeIsConst>
    │ │ │ │ +
    140 typename std::enable_if<enabled,Node&>::type
    │ │ │ │ +
    141 node ()
    │ │ │ │ +
    142 {
    │ │ │ │ +
    143 return static_cast<Node&>(*this);
    │ │ │ │ +
    144 }
    │ │ │ │ +
    145
    │ │ │ │ +
    146 const Node& node () const
    │ │ │ │ +
    147 {
    │ │ │ │ +
    148 return static_cast<const Node&>(*this);
    │ │ │ │ +
    149 }
    │ │ │ │ +
    150
    │ │ │ │ +
    151 public:
    │ │ │ │ +
    152
    │ │ │ │ +
    155
    │ │ │ │ +
    157
    │ │ │ │ +
    160 template<bool enabled = !proxiedNodeIsConst,
    │ │ │ │ +
    161 typename std::enable_if<enabled, int>::type = 0>
    │ │ │ │ +
    │ │ │ │ +
    162 auto& child (std::size_t i)
    │ │ │ │ +
    163 {
    │ │ │ │ +
    164 return node().proxiedNode().child(i);
    │ │ │ │ +
    165 }
    │ │ │ │ +
    │ │ │ │ +
    166
    │ │ │ │ +
    168
    │ │ │ │ +
    │ │ │ │ +
    171 const auto& child (std::size_t i) const
    │ │ │ │ +
    172 {
    │ │ │ │ +
    173 return node().proxiedNode().child(i);
    │ │ │ │ +
    174 }
    │ │ │ │ +
    │ │ │ │
    175
    │ │ │ │ -
    176 // the tree must support either dynamic or static traversal
    │ │ │ │ -
    177 static_assert(allowDynamicTraversal::value || allowStaticTraversal::value);
    │ │ │ │ -
    178
    │ │ │ │ -
    179 if constexpr(allowDynamicTraversal::value) {
    │ │ │ │ -
    180 // Specialization for dynamic traversal
    │ │ │ │ -
    181 for (std::size_t i = 0; i < tree.degree(); ++i) {
    │ │ │ │ -
    182 auto childTreePath = Dune::TypeTree::push_back(treePath, i);
    │ │ │ │ -
    183 forEachNode(tree.child(i), childTreePath, preFunc, leafFunc, postFunc);
    │ │ │ │ -
    184 }
    │ │ │ │ -
    185 } else if constexpr(allowStaticTraversal::value) {
    │ │ │ │ -
    186 // Specialization for static traversal
    │ │ │ │ -
    187 auto indices = std::make_index_sequence<Tree::degree()>{};
    │ │ │ │ -
    188 Hybrid::forEach(indices, [&](auto i) {
    │ │ │ │ -
    189 auto childTreePath = Dune::TypeTree::push_back(treePath, i);
    │ │ │ │ -
    190 forEachNode(tree.child(i), childTreePath, preFunc, leafFunc, postFunc);
    │ │ │ │ -
    191 });
    │ │ │ │ -
    192 }
    │ │ │ │ -
    193 postFunc(tree, treePath);
    │ │ │ │ -
    194 }
    │ │ │ │ -
    195 }
    │ │ │ │ +
    177
    │ │ │ │ +
    180 template<bool enabled = !proxiedNodeIsConst,
    │ │ │ │ +
    181 typename std::enable_if<enabled, int>::type = 0>
    │ │ │ │ +
    │ │ │ │ +
    182 auto childStorage (std::size_t i)
    │ │ │ │ +
    183 {
    │ │ │ │ +
    184 return node().proxiedNode().childStorage(i);
    │ │ │ │ +
    185 }
    │ │ │ │ +
    │ │ │ │ +
    186
    │ │ │ │ +
    188
    │ │ │ │ +
    │ │ │ │ +
    194 auto childStorage (std::size_t i) const
    │ │ │ │ +
    195 {
    │ │ │ │ +
    196 return node().proxiedNode().childStorage(i);
    │ │ │ │ +
    197 }
    │ │ │ │
    │ │ │ │ -
    196
    │ │ │ │ -
    197 } // namespace Detail
    │ │ │ │
    198
    │ │ │ │ -
    199
    │ │ │ │ -
    200 // ********************************************************************************
    │ │ │ │ -
    201 // Public Interface
    │ │ │ │ -
    202 // ********************************************************************************
    │ │ │ │ -
    203
    │ │ │ │ -
    217 template<class Tree, TreePathType::Type pathType=TreePathType::dynamic>
    │ │ │ │ -
    │ │ │ │ -
    218 constexpr auto leafTreePathTuple()
    │ │ │ │ -
    219 {
    │ │ │ │ -
    220 return Detail::leafTreePathTuple<std::decay_t<Tree>, pathType>(hybridTreePath());
    │ │ │ │ -
    221 }
    │ │ │ │ -
    │ │ │ │ -
    222
    │ │ │ │ -
    224
    │ │ │ │ -
    238 template<typename Tree, typename Visitor>
    │ │ │ │ -
    │ │ │ │ -
    239 void applyToTree(Tree&& tree, Visitor&& visitor)
    │ │ │ │ +
    200 template<class ProxyChild, bool enabled = !proxiedNodeIsConst>
    │ │ │ │ +
    │ │ │ │ +
    201 void setChild (std::size_t i, ProxyChild&& child, typename std::enable_if<enabled,void*>::type = 0)
    │ │ │ │ +
    202 {
    │ │ │ │ +
    203 node().proxiedNode().setChild(i, std::forward<ProxyChild>(child));
    │ │ │ │ +
    204 }
    │ │ │ │ +
    │ │ │ │ +
    205
    │ │ │ │ +
    206 };
    │ │ │ │ +
    │ │ │ │ +
    207
    │ │ │ │ +
    209 template<typename Node, typename NodeTag>
    │ │ │ │ +
    210 struct ProxyNodeBase;
    │ │ │ │ +
    211
    │ │ │ │ +
    213 template<typename Node>
    │ │ │ │ +
    │ │ │ │ +
    214 struct ProxyNodeBase<Node,LeafNodeTag>
    │ │ │ │ +
    215 {
    │ │ │ │ +
    216 };
    │ │ │ │ +
    │ │ │ │ +
    217
    │ │ │ │ +
    219 template<typename Node>
    │ │ │ │ +
    │ │ │ │ +
    220 struct ProxyNodeBase<Node,CompositeNodeTag>
    │ │ │ │ +
    221 : public StaticChildAccessors<Node>
    │ │ │ │ +
    222 {
    │ │ │ │ +
    223 typedef typename Node::ChildTypes ChildTypes;
    │ │ │ │ +
    224 typedef typename Node::NodeStorage NodeStorage;
    │ │ │ │ +
    225 };
    │ │ │ │ +
    │ │ │ │ +
    226
    │ │ │ │ +
    228 template<typename Node>
    │ │ │ │ +
    │ │ │ │ +
    229 struct ProxyNodeBase<Node,PowerNodeTag>
    │ │ │ │ +
    230 : public DynamicChildAccessors<Node>
    │ │ │ │ +
    231 {
    │ │ │ │ +
    232 typedef typename Node::ChildType ChildType;
    │ │ │ │ +
    233 typedef typename Node::NodeStorage NodeStorage;
    │ │ │ │ +
    234 };
    │ │ │ │ +
    │ │ │ │ +
    235
    │ │ │ │ +
    237 template<typename Node>
    │ │ │ │ +
    │ │ │ │ +
    238 struct ProxyNodeBase<Node,DynamicPowerNodeTag>
    │ │ │ │ +
    239 : public DynamicChildAccessors<Node>
    │ │ │ │
    240 {
    │ │ │ │ -
    241 Detail::applyToTree(tree, hybridTreePath(), visitor);
    │ │ │ │ -
    242 }
    │ │ │ │ -
    │ │ │ │ -
    243
    │ │ │ │ -
    253 template<class Tree, class NodeFunc>
    │ │ │ │ -
    │ │ │ │ -
    254 void forEachNode(Tree&& tree, NodeFunc&& nodeFunc)
    │ │ │ │ +
    241 typedef typename Node::ChildType ChildType;
    │ │ │ │ +
    242 typedef typename Node::NodeStorage NodeStorage;
    │ │ │ │ +
    243 };
    │ │ │ │ +
    │ │ │ │ +
    244
    │ │ │ │ +
    246
    │ │ │ │ +
    252 template<typename Node>
    │ │ │ │ +
    │ │ │ │ +
    253 class ProxyNode
    │ │ │ │ +
    254 : public ProxyNodeBase<Node,NodeTag<Node>>
    │ │ │ │
    255 {
    │ │ │ │ -
    256 Detail::forEachNode(tree, hybridTreePath(), nodeFunc, nodeFunc, NoOp{});
    │ │ │ │ -
    257 }
    │ │ │ │ -
    │ │ │ │ -
    258
    │ │ │ │ -
    268 template<class Tree, class LeafFunc>
    │ │ │ │ -
    │ │ │ │ -
    269 void forEachLeafNode(Tree&& tree, LeafFunc&& leafFunc)
    │ │ │ │ -
    270 {
    │ │ │ │ -
    271 Detail::forEachNode(tree, hybridTreePath(), NoOp{}, leafFunc, NoOp{});
    │ │ │ │ -
    272 }
    │ │ │ │ -
    │ │ │ │ +
    256 static const bool proxiedNodeIsConst = std::is_const<typename std::remove_reference<Node>::type>::value;
    │ │ │ │ +
    257
    │ │ │ │ +
    258 template <class N>
    │ │ │ │ +
    259 using HasStaticDegree = index_constant<N::degree()>;
    │ │ │ │ +
    260
    │ │ │ │ +
    261 template <class N>
    │ │ │ │ +
    262 static constexpr bool hasStaticDegree = Std::is_detected<HasStaticDegree, N>::value;
    │ │ │ │ +
    263
    │ │ │ │ +
    264 // accessor mixins need to be friends for access to proxiedNode()
    │ │ │ │ +
    265 friend class StaticChildAccessors<Node>;
    │ │ │ │ +
    266 friend class DynamicChildAccessors<Node>;
    │ │ │ │ +
    267
    │ │ │ │ +
    268 public:
    │ │ │ │ +
    269
    │ │ │ │ +
    270 typedef Node ProxiedNode;
    │ │ │ │ +
    271
    │ │ │ │ +
    272 typedef Dune::TypeTree::NodeTag<Node> NodeTag;
    │ │ │ │
    273
    │ │ │ │ -
    275
    │ │ │ │ -
    276 } // namespace TypeTree
    │ │ │ │ -
    277} //namespace Dune
    │ │ │ │ -
    278
    │ │ │ │ -
    279#endif // DUNE_TYPETREE_TRAVERSAL_HH
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -
    Dune::TypeTree::forEachNode
    void forEachNode(Tree &&tree, NodeFunc &&nodeFunc)
    Traverse tree and visit each node.
    Definition traversal.hh:254
    │ │ │ │ -
    Dune::TypeTree::leafTreePathTuple
    constexpr auto leafTreePathTuple()
    Create tuple of tree paths to leafs.
    Definition traversal.hh:218
    │ │ │ │ -
    Dune::TypeTree::forEachLeafNode
    void forEachLeafNode(Tree &&tree, LeafFunc &&leafFunc)
    Traverse tree and visit each leaf node.
    Definition traversal.hh:269
    │ │ │ │ -
    Dune::TypeTree::applyToTree
    void applyToTree(Tree &&tree, Visitor &&visitor)
    Apply visitor to TypeTree.
    Definition traversal.hh:239
    │ │ │ │ -
    Dune::TypeTree::Child
    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
    │ │ │ │ -
    Dune::TypeTree::child
    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
    │ │ │ │ -
    Dune::TypeTree::push_back
    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
    │ │ │ │ -
    Dune::TypeTree::hybridTreePath
    constexpr auto hybridTreePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:312
    │ │ │ │ -
    Dune::TypeTree::treePath
    constexpr auto treePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:326
    │ │ │ │ +
    275 static const bool isLeaf = Node::isLeaf;
    │ │ │ │ +
    276
    │ │ │ │ +
    278 static const bool isPower = Node::isPower;
    │ │ │ │ +
    279
    │ │ │ │ +
    281 static const bool isComposite = Node::isComposite;
    │ │ │ │ +
    282
    │ │ │ │ +
    283 template <class N = Node,
    │ │ │ │ +
    284 std::enable_if_t<hasStaticDegree<N>, int> = 0>
    │ │ │ │ +
    │ │ │ │ +
    285 static constexpr auto degree ()
    │ │ │ │ +
    286 {
    │ │ │ │ +
    287 return N::degree();
    │ │ │ │ +
    288 }
    │ │ │ │ +
    │ │ │ │ +
    289
    │ │ │ │ +
    290 template <class N = Node,
    │ │ │ │ +
    291 std::enable_if_t<not hasStaticDegree<N>, int> = 0>
    │ │ │ │ +
    │ │ │ │ +
    292 auto degree () const
    │ │ │ │ +
    293 {
    │ │ │ │ +
    294 return proxiedNode().degree();
    │ │ │ │ +
    295 }
    │ │ │ │ +
    │ │ │ │ +
    296
    │ │ │ │ +
    297
    │ │ │ │ +
    298 protected:
    │ │ │ │ +
    299
    │ │ │ │ +
    302
    │ │ │ │ +
    304 template<bool enabled = !proxiedNodeIsConst>
    │ │ │ │ +
    305 typename std::enable_if<enabled,Node&>::type
    │ │ │ │ +
    │ │ │ │ +
    306 proxiedNode ()
    │ │ │ │ +
    307 {
    │ │ │ │ +
    308 return *_node;
    │ │ │ │ +
    309 }
    │ │ │ │ +
    │ │ │ │ +
    310
    │ │ │ │ +
    │ │ │ │ +
    312 const Node& proxiedNode () const
    │ │ │ │ +
    313 {
    │ │ │ │ +
    314 return *_node;
    │ │ │ │ +
    315 }
    │ │ │ │ +
    │ │ │ │ +
    316
    │ │ │ │ +
    318 template<bool enabled = !proxiedNodeIsConst>
    │ │ │ │ +
    319 typename std::enable_if<enabled,std::shared_ptr<Node> >::type
    │ │ │ │ +
    │ │ │ │ +
    320 proxiedNodeStorage ()
    │ │ │ │ +
    321 {
    │ │ │ │ +
    322 return _node;
    │ │ │ │ +
    323 }
    │ │ │ │ +
    │ │ │ │ +
    324
    │ │ │ │ +
    │ │ │ │ +
    326 std::shared_ptr<const Node> proxiedNodeStorage () const
    │ │ │ │ +
    327 {
    │ │ │ │ +
    328 return _node;
    │ │ │ │ +
    329 }
    │ │ │ │ +
    │ │ │ │ +
    330
    │ │ │ │ +
    332
    │ │ │ │ +
    335
    │ │ │ │ +
    │ │ │ │ +
    336 ProxyNode (Node& node)
    │ │ │ │ +
    337 : _node(stackobject_to_shared_ptr(node))
    │ │ │ │ +
    338 {}
    │ │ │ │ +
    │ │ │ │ +
    339
    │ │ │ │ +
    │ │ │ │ +
    340 ProxyNode (std::shared_ptr<Node> node)
    │ │ │ │ +
    341 : _node(std::move(node))
    │ │ │ │ +
    342 {}
    │ │ │ │ +
    │ │ │ │ +
    343
    │ │ │ │ +
    345
    │ │ │ │ +
    346 private:
    │ │ │ │ +
    347
    │ │ │ │ +
    348 std::shared_ptr<Node> _node;
    │ │ │ │ +
    349 };
    │ │ │ │ +
    │ │ │ │ +
    350
    │ │ │ │ +
    352
    │ │ │ │ +
    353 } // namespace TypeTree
    │ │ │ │ +
    354} //namespace Dune
    │ │ │ │ +
    355
    │ │ │ │ +
    356#endif // DUNE_TYPETREE_PROXYNODE_HH
    │ │ │ │ + │ │ │ │ + │ │ │ │ +
    Dune::TypeTree::NodeTag
    typename std::decay_t< Node >::NodeTag NodeTag
    Returns the node tag of the given Node.
    Definition nodeinterface.hh:70
    │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::Detail::forEachNode
    void forEachNode(T &&tree, TreePath treePath, PreFunc &&preFunc, LeafFunc &&leafFunc, PostFunc &&postFunc)
    Definition traversal.hh:164
    │ │ │ │ -
    Dune::TypeTree::Detail::DynamicTraversalConcept
    decltype((std::declval< Tree >().degree(), std::declval< Tree >().child(0u))) DynamicTraversalConcept
    Definition traversal.hh:43
    │ │ │ │ -
    Dune::TypeTree::Detail::StaticTraversalConcept
    decltype((std::integral_constant< std::size_t, Tree::degree()>{})) StaticTraversalConcept
    Definition traversal.hh:49
    │ │ │ │ -
    Dune::TypeTree::Detail::applyToTree
    void applyToTree(T &&tree, TreePath treePath, V &&visitor)
    Definition traversal.hh:97
    │ │ │ │ -
    Dune::TypeTree::Detail::leafTreePathTuple
    constexpr auto leafTreePathTuple(Prefix prefix)
    Definition traversal.hh:54
    │ │ │ │ -
    Dune::TypeTree::TreePathType::Type
    Type
    Definition treepath.hh:106
    │ │ │ │ -
    Dune::TypeTree::TreePathType::dynamic
    @ dynamic
    Definition treepath.hh:106
    │ │ │ │ +
    Dune::TypeTree::LeafNodeTag
    Tag designating a leaf node.
    Definition nodetags.hh:18
    │ │ │ │ +
    Dune::TypeTree::PowerNodeTag
    Tag designating a power node.
    Definition nodetags.hh:21
    │ │ │ │ +
    Dune::TypeTree::DynamicPowerNodeTag
    Tag designating a power node with runtime degree.
    Definition nodetags.hh:24
    │ │ │ │ +
    Dune::TypeTree::CompositeNodeTag
    Tag designating a composite node.
    Definition nodetags.hh:27
    │ │ │ │ +
    Dune::TypeTree::ProxyNode
    Base class for nodes acting as a proxy for an existing node.
    Definition proxynode.hh:255
    │ │ │ │ +
    Dune::TypeTree::ProxyNode::ProxyNode
    ProxyNode(Node &node)
    Definition proxynode.hh:336
    │ │ │ │ +
    Dune::TypeTree::ProxyNode::NodeTag
    Dune::TypeTree::NodeTag< Node > NodeTag
    Definition proxynode.hh:272
    │ │ │ │ +
    Dune::TypeTree::ProxyNode::isComposite
    static const bool isComposite
    Mark this class as a composite in the dune-typetree.
    Definition proxynode.hh:281
    │ │ │ │ +
    Dune::TypeTree::ProxyNode::isLeaf
    static const bool isLeaf
    Mark this class as non leaf in the dune-typetree.
    Definition proxynode.hh:275
    │ │ │ │ +
    Dune::TypeTree::ProxyNode::isPower
    static const bool isPower
    Mark this class as a non power in the dune-typetree.
    Definition proxynode.hh:278
    │ │ │ │ +
    Dune::TypeTree::ProxyNode::degree
    auto degree() const
    Definition proxynode.hh:292
    │ │ │ │ +
    Dune::TypeTree::ProxyNode::proxiedNode
    std::enable_if< enabled, Node & >::type proxiedNode()
    Returns the proxied node.
    Definition proxynode.hh:306
    │ │ │ │ +
    Dune::TypeTree::ProxyNode::proxiedNodeStorage
    std::shared_ptr< const Node > proxiedNodeStorage() const
    Returns the storage of the proxied node (const version).
    Definition proxynode.hh:326
    │ │ │ │ +
    Dune::TypeTree::ProxyNode::ProxiedNode
    Node ProxiedNode
    Definition proxynode.hh:270
    │ │ │ │ +
    Dune::TypeTree::ProxyNode::proxiedNodeStorage
    std::enable_if< enabled, std::shared_ptr< Node > >::type proxiedNodeStorage()
    Returns the storage of the proxied node.
    Definition proxynode.hh:320
    │ │ │ │ +
    Dune::TypeTree::ProxyNode::degree
    static constexpr auto degree()
    Definition proxynode.hh:285
    │ │ │ │ +
    Dune::TypeTree::ProxyNode::ProxyNode
    ProxyNode(std::shared_ptr< Node > node)
    Definition proxynode.hh:340
    │ │ │ │ +
    Dune::TypeTree::ProxyNode::proxiedNode
    const Node & proxiedNode() const
    Returns the proxied node (const version).
    Definition proxynode.hh:312
    │ │ │ │ +
    Dune::TypeTree::StaticChildAccessors
    Mixin class providing methods for child access with compile-time parameter.
    Definition proxynode.hh:30
    │ │ │ │ +
    Dune::TypeTree::StaticChildAccessors::child
    auto & child(index_constant< k >={})
    Returns the i-th child.
    Definition proxynode.hh:71
    │ │ │ │ +
    Dune::TypeTree::StaticChildAccessors::setChild
    void setChild(ProxyChild &&child, typename std::enable_if< lazy_enabled< k >::value, void * >::type=0)
    Sets the i-th child to the passed-in value.
    Definition proxynode.hh:112
    │ │ │ │ +
    Dune::TypeTree::StaticChildAccessors::nodeStorage
    const ProxiedNode::NodeStorage & nodeStorage() const
    Definition proxynode.hh:117
    │ │ │ │ +
    Dune::TypeTree::StaticChildAccessors::childStorage
    auto childStorage(index_constant< k >={})
    Returns the storage of the i-th child.
    Definition proxynode.hh:92
    │ │ │ │ +
    Dune::TypeTree::StaticChildAccessors::child
    const auto & child(index_constant< k >={}) const
    Returns the i-th child (const version).
    Definition proxynode.hh:81
    │ │ │ │ +
    Dune::TypeTree::StaticChildAccessors::childStorage
    auto childStorage(index_constant< k >={}) const
    Returns the storage of the i-th child (const version).
    Definition proxynode.hh:105
    │ │ │ │ +
    Dune::TypeTree::StaticChildAccessors::Child
    Access to the type and storage type of the i-th child.
    Definition proxynode.hh:60
    │ │ │ │ +
    Dune::TypeTree::DynamicChildAccessors
    Mixin class providing methods for child access with run-time parameter.
    Definition proxynode.hh:133
    │ │ │ │ +
    Dune::TypeTree::DynamicChildAccessors::child
    auto & child(std::size_t i)
    Returns the i-th child.
    Definition proxynode.hh:162
    │ │ │ │ +
    Dune::TypeTree::DynamicChildAccessors::childStorage
    auto childStorage(std::size_t i) const
    Returns the storage of the i-th child (const version).
    Definition proxynode.hh:194
    │ │ │ │ +
    Dune::TypeTree::DynamicChildAccessors::setChild
    void setChild(std::size_t i, ProxyChild &&child, typename std::enable_if< enabled, void * >::type=0)
    Sets the i-th child to the passed-in value.
    Definition proxynode.hh:201
    │ │ │ │ +
    Dune::TypeTree::DynamicChildAccessors::child
    const auto & child(std::size_t i) const
    Returns the i-th child (const version).
    Definition proxynode.hh:171
    │ │ │ │ +
    Dune::TypeTree::DynamicChildAccessors::childStorage
    auto childStorage(std::size_t i)
    Returns the storage of the i-th child.
    Definition proxynode.hh:182
    │ │ │ │ +
    Dune::TypeTree::ProxyNodeBase
    Tag-based dispatch to appropriate base class that provides necessary functionality.
    Definition proxynode.hh:210
    │ │ │ │ +
    Dune::TypeTree::ProxyNodeBase< Node, CompositeNodeTag >::NodeStorage
    Node::NodeStorage NodeStorage
    Definition proxynode.hh:224
    │ │ │ │ +
    Dune::TypeTree::ProxyNodeBase< Node, CompositeNodeTag >::ChildTypes
    Node::ChildTypes ChildTypes
    Definition proxynode.hh:223
    │ │ │ │ +
    Dune::TypeTree::ProxyNodeBase< Node, PowerNodeTag >::NodeStorage
    Node::NodeStorage NodeStorage
    Definition proxynode.hh:233
    │ │ │ │ +
    Dune::TypeTree::ProxyNodeBase< Node, PowerNodeTag >::ChildType
    Node::ChildType ChildType
    Definition proxynode.hh:232
    │ │ │ │ +
    Dune::TypeTree::ProxyNodeBase< Node, DynamicPowerNodeTag >::NodeStorage
    Node::NodeStorage NodeStorage
    Definition proxynode.hh:242
    │ │ │ │ +
    Dune::TypeTree::ProxyNodeBase< Node, DynamicPowerNodeTag >::ChildType
    Node::ChildType ChildType
    Definition proxynode.hh:241
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,333 +1,446 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -traversal.hh │ │ │ │ │ +proxynode.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_TRAVERSAL_HH │ │ │ │ │ -7#define DUNE_TYPETREE_TRAVERSAL_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_PROXYNODE_HH │ │ │ │ │ +7#define DUNE_TYPETREE_PROXYNODE_HH │ │ │ │ │ 8 │ │ │ │ │ -9#include │ │ │ │ │ -10 │ │ │ │ │ -11#include │ │ │ │ │ -12#include │ │ │ │ │ -13 │ │ │ │ │ -14#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h> │ │ │ │ │ -15#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ -16#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_t_r_e_e_p_a_t_h_._h_h> │ │ │ │ │ -17#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_v_i_s_i_t_o_r_._h_h> │ │ │ │ │ +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 │ │ │ │ │ +13#include │ │ │ │ │ +14#include │ │ │ │ │ +15 │ │ │ │ │ +16namespace _D_u_n_e { │ │ │ │ │ +17 namespace TypeTree { │ │ │ │ │ 18 │ │ │ │ │ -19namespace _D_u_n_e { │ │ │ │ │ -20 namespace TypeTree { │ │ │ │ │ -21 │ │ │ │ │ -27#ifndef DOXYGEN │ │ │ │ │ -29 struct NoOp │ │ │ │ │ +24 template │ │ │ │ │ +25 class ProxyNode; │ │ │ │ │ +26 │ │ │ │ │ +28 template │ │ │ │ │ +_2_9 class _S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s │ │ │ │ │ 30 { │ │ │ │ │ -31 template │ │ │ │ │ -32 constexpr void operator()(T&&...) const { /* do nothing */ } │ │ │ │ │ -33 }; │ │ │ │ │ -34#endif │ │ │ │ │ -35 │ │ │ │ │ -36 namespace Detail { │ │ │ │ │ -37 │ │ │ │ │ -38 // SFINAE template check that Tree has a degree() function and a child() │ │ │ │ │ -function accepting integer indices │ │ │ │ │ -39 template │ │ │ │ │ -_4_0 using _D_y_n_a_m_i_c_T_r_a_v_e_r_s_a_l_C_o_n_c_e_p_t = decltype(( │ │ │ │ │ -41 std::declval().degree(), │ │ │ │ │ -42 std::declval().child(0u) │ │ │ │ │ -43 )); │ │ │ │ │ -44 │ │ │ │ │ -45 // SFINAE template check that Tree has static (constexpr) function Tree:: │ │ │ │ │ -degree() │ │ │ │ │ -46 template │ │ │ │ │ -_4_7 using _S_t_a_t_i_c_T_r_a_v_e_r_s_a_l_C_o_n_c_e_p_t = decltype(( │ │ │ │ │ -48 std::integral_constant{} │ │ │ │ │ -49 )); │ │ │ │ │ -50 │ │ │ │ │ -51 │ │ │ │ │ -52 template = 0> │ │ │ │ │ -_5_4 constexpr auto _l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e(Prefix prefix) │ │ │ │ │ -55 { │ │ │ │ │ -56 return std::make_tuple(prefix); │ │ │ │ │ -57 } │ │ │ │ │ -58 │ │ │ │ │ -59 template = 0> │ │ │ │ │ -61 constexpr auto _l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e(Prefix prefix); │ │ │ │ │ -62 │ │ │ │ │ -63 template = 0> │ │ │ │ │ -_6_5 constexpr auto _l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e(Prefix prefix, std:: │ │ │ │ │ -index_sequence) │ │ │ │ │ -66 { │ │ │ │ │ -67 return std::tuple_cat(_D_e_t_a_i_l_:_:_l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e<_T_y_p_e_T_r_e_e_:_: │ │ │ │ │ -_C_h_i_l_d_<_T_r_e_e_,_i_n_d_i_c_e_s_>, pathType>(_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_u_s_h___b_a_c_k(prefix, Dune:: │ │ │ │ │ -index_constant{}))...); │ │ │ │ │ -68 } │ │ │ │ │ -69 │ │ │ │ │ -70 template │ │ │ │ │ -= 0> │ │ │ │ │ -72 constexpr auto _l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e(Prefix prefix, std:: │ │ │ │ │ -index_sequence) │ │ │ │ │ -73 { │ │ │ │ │ -74 return std::tuple_cat(_D_e_t_a_i_l_:_:_l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e<_T_y_p_e_T_r_e_e_:_: │ │ │ │ │ -_C_h_i_l_d_<_T_r_e_e_,_i_n_d_i_c_e_s_>, pathType>(_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_p_u_s_h___b_a_c_k(prefix, indices))...); │ │ │ │ │ -75 } │ │ │ │ │ -76 │ │ │ │ │ -77 template> │ │ │ │ │ -79 constexpr auto _l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e(Prefix prefix) │ │ │ │ │ -80 { │ │ │ │ │ -81 return Detail::leafTreePathTuple(prefix, std:: │ │ │ │ │ -make_index_sequence{}); │ │ │ │ │ -82 } │ │ │ │ │ -83 │ │ │ │ │ -84 /* The signature is the same as for the public applyToTree │ │ │ │ │ -85 * function in Dune::Typetree, despite the additionally passed │ │ │ │ │ -86 * treePath argument. The path passed here is associated to │ │ │ │ │ -87 * the tree and the relative paths of the children (wrt. to tree) │ │ │ │ │ -88 * are appended to this. Hence the behavior of the public function │ │ │ │ │ -89 * is resembled by passing an empty treePath. │ │ │ │ │ -90 */ │ │ │ │ │ -91 │ │ │ │ │ -92 /* │ │ │ │ │ -93 * This is the overload for leaf traversal │ │ │ │ │ -94 */ │ │ │ │ │ -95 template::isLeaf, int> = 0> │ │ │ │ │ -_9_7 void _a_p_p_l_y_T_o_T_r_e_e(T&& tree, TreePath _t_r_e_e_P_a_t_h, V&& visitor) │ │ │ │ │ -98 { │ │ │ │ │ -99 visitor.leaf(tree, _t_r_e_e_P_a_t_h); │ │ │ │ │ -100 } │ │ │ │ │ -101 │ │ │ │ │ -102 /* │ │ │ │ │ -103 * This is the general overload doing child traversal. │ │ │ │ │ -104 */ │ │ │ │ │ -105 template::isLeaf, int> = 0> │ │ │ │ │ -107 void _a_p_p_l_y_T_o_T_r_e_e(T&& tree, TreePath _t_r_e_e_P_a_t_h, V&& visitor) │ │ │ │ │ -108 { │ │ │ │ │ -109 using Tree = std::remove_reference_t; │ │ │ │ │ -110 using Visitor = std::remove_reference_t; │ │ │ │ │ -111 visitor.pre(tree, _t_r_e_e_P_a_t_h); │ │ │ │ │ -112 │ │ │ │ │ -113 // check which type of traversal is supported by the tree │ │ │ │ │ -114 using allowDynamicTraversal = Dune::Std:: │ │ │ │ │ -is_detected; │ │ │ │ │ -115 using allowStaticTraversal = Dune::Std:: │ │ │ │ │ -is_detected; │ │ │ │ │ +31 │ │ │ │ │ +32 static const bool proxiedNodeIsConst = std::is_const::type>::value; │ │ │ │ │ +33 │ │ │ │ │ +34 template │ │ │ │ │ +35 struct lazy_enabled │ │ │ │ │ +36 { │ │ │ │ │ +37 static const bool value = !proxiedNodeIsConst; │ │ │ │ │ +38 }; │ │ │ │ │ +39 │ │ │ │ │ +40 typedef _P_r_o_x_y_N_o_d_e_<_P_r_o_x_i_e_d_N_o_d_e_> _N_o_d_e; │ │ │ │ │ +41 │ │ │ │ │ +42 template │ │ │ │ │ +43 typename std::enable_if::type │ │ │ │ │ +44 node () │ │ │ │ │ +45 { │ │ │ │ │ +46 return static_cast<_N_o_d_e&>(*this); │ │ │ │ │ +47 } │ │ │ │ │ +48 │ │ │ │ │ +49 const _N_o_d_e& node () const │ │ │ │ │ +50 { │ │ │ │ │ +51 return static_cast(*this); │ │ │ │ │ +52 } │ │ │ │ │ +53 │ │ │ │ │ +54 public: │ │ │ │ │ +55 │ │ │ │ │ +57 template │ │ │ │ │ +_5_8 struct _C_h_i_l_d │ │ │ │ │ +59 : public ProxiedNode::template _C_h_i_l_d │ │ │ │ │ +60 {}; │ │ │ │ │ +61 │ │ │ │ │ +64 │ │ │ │ │ +66 │ │ │ │ │ +69 template::value, int>::type = 0> │ │ │ │ │ +_7_1 auto& _c_h_i_l_d (index_constant = {}) │ │ │ │ │ +72 { │ │ │ │ │ +73 return node().proxiedNode().template child(); │ │ │ │ │ +74 } │ │ │ │ │ +75 │ │ │ │ │ +77 │ │ │ │ │ +80 template │ │ │ │ │ +_8_1 const auto& _c_h_i_l_d (index_constant = {}) const │ │ │ │ │ +82 { │ │ │ │ │ +83 return node().proxiedNode().template child(); │ │ │ │ │ +84 } │ │ │ │ │ +85 │ │ │ │ │ +87 │ │ │ │ │ +90 template::value, int>::type = 0> │ │ │ │ │ +_9_2 auto _c_h_i_l_d_S_t_o_r_a_g_e (index_constant = {}) │ │ │ │ │ +93 { │ │ │ │ │ +94 return node().proxiedNode().template childStorage(); │ │ │ │ │ +95 } │ │ │ │ │ +96 │ │ │ │ │ +98 │ │ │ │ │ +104 template │ │ │ │ │ +_1_0_5 auto _c_h_i_l_d_S_t_o_r_a_g_e (index_constant = {}) const │ │ │ │ │ +106 { │ │ │ │ │ +107 return node().proxiedNode().template childStorage(); │ │ │ │ │ +108 } │ │ │ │ │ +109 │ │ │ │ │ +111 template │ │ │ │ │ +_1_1_2 void _s_e_t_C_h_i_l_d (ProxyChild&& _c_h_i_l_d, typename std:: │ │ │ │ │ +enable_if::value,void*>::type = 0) │ │ │ │ │ +113 { │ │ │ │ │ +114 node().proxiedNode().template setChild(std::forward(_c_h_i_l_d)); │ │ │ │ │ +115 } │ │ │ │ │ 116 │ │ │ │ │ -117 // the tree must support either dynamic or static traversal │ │ │ │ │ -118 static_assert(allowDynamicTraversal::value || allowStaticTraversal::value); │ │ │ │ │ -119 │ │ │ │ │ -120 // the visitor may specify preferred dynamic traversal │ │ │ │ │ -121 using preferDynamicTraversal = std::bool_constant; │ │ │ │ │ -122 │ │ │ │ │ -123 // create a dynamic or static index range │ │ │ │ │ -124 auto indices = [&]{ │ │ │ │ │ -125 if constexpr(preferDynamicTraversal::value && allowDynamicTraversal::value) │ │ │ │ │ -126 return Dune::range(std::size_t(tree.degree())); │ │ │ │ │ -127 else │ │ │ │ │ -128 return Dune::range(tree.degree()); │ │ │ │ │ -129 }(); │ │ │ │ │ -130 │ │ │ │ │ -131 if constexpr(allowDynamicTraversal::value || allowStaticTraversal::value) { │ │ │ │ │ -132 Hybrid::forEach(indices, [&](auto i) { │ │ │ │ │ -133 auto&& _c_h_i_l_d = tree.child(i); │ │ │ │ │ -134 using _C_h_i_l_d = std::decay_t; │ │ │ │ │ -135 │ │ │ │ │ -136 visitor.beforeChild(tree, _c_h_i_l_d, _t_r_e_e_P_a_t_h, i); │ │ │ │ │ -137 │ │ │ │ │ -138 // This requires that visitor.in(...) can always be instantiated, │ │ │ │ │ -139 // even if there's a single child only. │ │ │ │ │ -140 if (i>0) │ │ │ │ │ -141 visitor.in(tree, _t_r_e_e_P_a_t_h); │ │ │ │ │ -142 │ │ │ │ │ -143 constexpr bool visitChild = Visitor::template │ │ │ │ │ -VisitChild::value; │ │ │ │ │ -144 if constexpr(visitChild) { │ │ │ │ │ -145 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); │ │ │ │ │ -146 _a_p_p_l_y_T_o_T_r_e_e(_c_h_i_l_d, childTreePath, visitor); │ │ │ │ │ -147 } │ │ │ │ │ -148 │ │ │ │ │ -149 visitor.afterChild(tree, _c_h_i_l_d, _t_r_e_e_P_a_t_h, i); │ │ │ │ │ -150 }); │ │ │ │ │ -151 } │ │ │ │ │ -152 visitor.post(tree, _t_r_e_e_P_a_t_h); │ │ │ │ │ -153 } │ │ │ │ │ -154 │ │ │ │ │ -155 /* Traverse tree and visit each node. The signature is the same │ │ │ │ │ -156 * as for the public forEachNode function in Dune::Typtree, │ │ │ │ │ -157 * despite the additionally passed treePath argument. The path │ │ │ │ │ -158 * passed here is associated to the tree and the relative │ │ │ │ │ -159 * paths of the children (wrt. to tree) are appended to this. │ │ │ │ │ -160 * Hence the behavior of the public function is resembled │ │ │ │ │ -161 * by passing an empty treePath. │ │ │ │ │ -162 */ │ │ │ │ │ -163 template │ │ │ │ │ -_1_6_4 void _f_o_r_E_a_c_h_N_o_d_e(T&& tree, TreePath _t_r_e_e_P_a_t_h, PreFunc&& preFunc, LeafFunc&& │ │ │ │ │ -leafFunc, PostFunc&& postFunc) │ │ │ │ │ -165 { │ │ │ │ │ -166 using Tree = std::decay_t; │ │ │ │ │ -167 if constexpr(Tree::isLeaf) { │ │ │ │ │ -168 leafFunc(tree, _t_r_e_e_P_a_t_h); │ │ │ │ │ -169 } else { │ │ │ │ │ -170 preFunc(tree, _t_r_e_e_P_a_t_h); │ │ │ │ │ -171 │ │ │ │ │ -172 // check which type of traversal is supported by the tree, prefer dynamic │ │ │ │ │ -traversal │ │ │ │ │ -173 using allowDynamicTraversal = Dune::Std:: │ │ │ │ │ -is_detected; │ │ │ │ │ -174 using allowStaticTraversal = Dune::Std:: │ │ │ │ │ -is_detected; │ │ │ │ │ +_1_1_7 const typename ProxiedNode::NodeStorage& _n_o_d_e_S_t_o_r_a_g_e () const │ │ │ │ │ +118 { │ │ │ │ │ +119 return node().proxiedNode().nodeStorage(); │ │ │ │ │ +120 } │ │ │ │ │ +121 │ │ │ │ │ +122 }; │ │ │ │ │ +123 │ │ │ │ │ +125 │ │ │ │ │ +130 template │ │ │ │ │ +_1_3_1 class _D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s │ │ │ │ │ +132 : public _S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s │ │ │ │ │ +133 { │ │ │ │ │ +134 │ │ │ │ │ +135 typedef _P_r_o_x_y_N_o_d_e_<_P_r_o_x_i_e_d_N_o_d_e_> _N_o_d_e; │ │ │ │ │ +136 │ │ │ │ │ +137 static const bool proxiedNodeIsConst = std::is_const::type>::value; │ │ │ │ │ +138 │ │ │ │ │ +139 template │ │ │ │ │ +140 typename std::enable_if::type │ │ │ │ │ +141 node () │ │ │ │ │ +142 { │ │ │ │ │ +143 return static_cast<_N_o_d_e&>(*this); │ │ │ │ │ +144 } │ │ │ │ │ +145 │ │ │ │ │ +146 const _N_o_d_e& node () const │ │ │ │ │ +147 { │ │ │ │ │ +148 return static_cast(*this); │ │ │ │ │ +149 } │ │ │ │ │ +150 │ │ │ │ │ +151 public: │ │ │ │ │ +152 │ │ │ │ │ +155 │ │ │ │ │ +157 │ │ │ │ │ +160 template::type = 0> │ │ │ │ │ +_1_6_2 auto& _c_h_i_l_d (std::size_t i) │ │ │ │ │ +163 { │ │ │ │ │ +164 return node().proxiedNode().child(i); │ │ │ │ │ +165 } │ │ │ │ │ +166 │ │ │ │ │ +168 │ │ │ │ │ +_1_7_1 const auto& _c_h_i_l_d (std::size_t i) const │ │ │ │ │ +172 { │ │ │ │ │ +173 return node().proxiedNode().child(i); │ │ │ │ │ +174 } │ │ │ │ │ 175 │ │ │ │ │ -176 // the tree must support either dynamic or static traversal │ │ │ │ │ -177 static_assert(allowDynamicTraversal::value || allowStaticTraversal::value); │ │ │ │ │ -178 │ │ │ │ │ -179 if constexpr(allowDynamicTraversal::value) { │ │ │ │ │ -180 // Specialization for dynamic traversal │ │ │ │ │ -181 for (std::size_t i = 0; i < tree.degree(); ++i) { │ │ │ │ │ -182 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); │ │ │ │ │ -183 _f_o_r_E_a_c_h_N_o_d_e(tree.child(i), childTreePath, preFunc, leafFunc, postFunc); │ │ │ │ │ -184 } │ │ │ │ │ -185 } else if constexpr(allowStaticTraversal::value) { │ │ │ │ │ -186 // Specialization for static traversal │ │ │ │ │ -187 auto indices = std::make_index_sequence{}; │ │ │ │ │ -188 Hybrid::forEach(indices, [&](auto i) { │ │ │ │ │ -189 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); │ │ │ │ │ -190 _f_o_r_E_a_c_h_N_o_d_e(tree.child(i), childTreePath, preFunc, leafFunc, postFunc); │ │ │ │ │ -191 }); │ │ │ │ │ -192 } │ │ │ │ │ -193 postFunc(tree, _t_r_e_e_P_a_t_h); │ │ │ │ │ -194 } │ │ │ │ │ -195 } │ │ │ │ │ -196 │ │ │ │ │ -197 } // namespace Detail │ │ │ │ │ +177 │ │ │ │ │ +180 template::type = 0> │ │ │ │ │ +_1_8_2 auto _c_h_i_l_d_S_t_o_r_a_g_e (std::size_t i) │ │ │ │ │ +183 { │ │ │ │ │ +184 return node().proxiedNode().childStorage(i); │ │ │ │ │ +185 } │ │ │ │ │ +186 │ │ │ │ │ +188 │ │ │ │ │ +_1_9_4 auto _c_h_i_l_d_S_t_o_r_a_g_e (std::size_t i) const │ │ │ │ │ +195 { │ │ │ │ │ +196 return node().proxiedNode().childStorage(i); │ │ │ │ │ +197 } │ │ │ │ │ 198 │ │ │ │ │ -199 │ │ │ │ │ -200 / │ │ │ │ │ -/ │ │ │ │ │ -******************************************************************************** │ │ │ │ │ -201 // Public Interface │ │ │ │ │ -202 / │ │ │ │ │ -/ │ │ │ │ │ -******************************************************************************** │ │ │ │ │ -203 │ │ │ │ │ -217 template │ │ │ │ │ -_2_1_8 constexpr auto _l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e() │ │ │ │ │ -219 { │ │ │ │ │ -220 return Detail::leafTreePathTuple, pathType> │ │ │ │ │ -(_h_y_b_r_i_d_T_r_e_e_P_a_t_h()); │ │ │ │ │ -221 } │ │ │ │ │ -222 │ │ │ │ │ -224 │ │ │ │ │ -238 template │ │ │ │ │ -_2_3_9 void _a_p_p_l_y_T_o_T_r_e_e(Tree&& tree, Visitor&& visitor) │ │ │ │ │ +200 template │ │ │ │ │ +_2_0_1 void _s_e_t_C_h_i_l_d (std::size_t i, ProxyChild&& _c_h_i_l_d, typename std:: │ │ │ │ │ +enable_if::type = 0) │ │ │ │ │ +202 { │ │ │ │ │ +203 node().proxiedNode().setChild(i, std::forward(_c_h_i_l_d)); │ │ │ │ │ +204 } │ │ │ │ │ +205 │ │ │ │ │ +206 }; │ │ │ │ │ +207 │ │ │ │ │ +209 template │ │ │ │ │ +_2_1_0 struct _P_r_o_x_y_N_o_d_e_B_a_s_e; │ │ │ │ │ +211 │ │ │ │ │ +213 template │ │ │ │ │ +_2_1_4 struct _P_r_o_x_y_N_o_d_e_B_a_s_e │ │ │ │ │ +215 { │ │ │ │ │ +216 }; │ │ │ │ │ +217 │ │ │ │ │ +219 template │ │ │ │ │ +_2_2_0 struct _P_r_o_x_y_N_o_d_e_B_a_s_e<_N_o_d_e,_C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g> │ │ │ │ │ +221 : public _S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s │ │ │ │ │ +222 { │ │ │ │ │ +_2_2_3 typedef typename Node::ChildTypes _C_h_i_l_d_T_y_p_e_s; │ │ │ │ │ +_2_2_4 typedef typename Node::NodeStorage _N_o_d_e_S_t_o_r_a_g_e; │ │ │ │ │ +225 }; │ │ │ │ │ +226 │ │ │ │ │ +228 template │ │ │ │ │ +_2_2_9 struct _P_r_o_x_y_N_o_d_e_B_a_s_e<_N_o_d_e,_P_o_w_e_r_N_o_d_e_T_a_g> │ │ │ │ │ +230 : public _D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s │ │ │ │ │ +231 { │ │ │ │ │ +_2_3_2 typedef typename Node::ChildType _C_h_i_l_d_T_y_p_e; │ │ │ │ │ +_2_3_3 typedef typename Node::NodeStorage _N_o_d_e_S_t_o_r_a_g_e; │ │ │ │ │ +234 }; │ │ │ │ │ +235 │ │ │ │ │ +237 template │ │ │ │ │ +_2_3_8 struct _P_r_o_x_y_N_o_d_e_B_a_s_e<_N_o_d_e,_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g> │ │ │ │ │ +239 : public _D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s │ │ │ │ │ 240 { │ │ │ │ │ -241 _D_e_t_a_i_l_:_:_a_p_p_l_y_T_o_T_r_e_e(tree, _h_y_b_r_i_d_T_r_e_e_P_a_t_h(), visitor); │ │ │ │ │ -242 } │ │ │ │ │ -243 │ │ │ │ │ -253 template │ │ │ │ │ -_2_5_4 void _f_o_r_E_a_c_h_N_o_d_e(Tree&& tree, NodeFunc&& nodeFunc) │ │ │ │ │ +_2_4_1 typedef typename Node::ChildType _C_h_i_l_d_T_y_p_e; │ │ │ │ │ +_2_4_2 typedef typename Node::NodeStorage _N_o_d_e_S_t_o_r_a_g_e; │ │ │ │ │ +243 }; │ │ │ │ │ +244 │ │ │ │ │ +246 │ │ │ │ │ +252 template │ │ │ │ │ +_2_5_3 class _P_r_o_x_y_N_o_d_e │ │ │ │ │ +254 : public _P_r_o_x_y_N_o_d_e_B_a_s_e> │ │ │ │ │ 255 { │ │ │ │ │ -256 _D_e_t_a_i_l_:_:_f_o_r_E_a_c_h_N_o_d_e(tree, _h_y_b_r_i_d_T_r_e_e_P_a_t_h(), nodeFunc, nodeFunc, NoOp{}); │ │ │ │ │ -257 } │ │ │ │ │ -258 │ │ │ │ │ -268 template │ │ │ │ │ -_2_6_9 void _f_o_r_E_a_c_h_L_e_a_f_N_o_d_e(Tree&& tree, LeafFunc&& leafFunc) │ │ │ │ │ -270 { │ │ │ │ │ -271 _D_e_t_a_i_l_:_:_f_o_r_E_a_c_h_N_o_d_e(tree, _h_y_b_r_i_d_T_r_e_e_P_a_t_h(), NoOp{}, leafFunc, NoOp{}); │ │ │ │ │ -272 } │ │ │ │ │ +256 static const bool proxiedNodeIsConst = std::is_const::type>::value; │ │ │ │ │ +257 │ │ │ │ │ +258 template │ │ │ │ │ +259 using HasStaticDegree = index_constant; │ │ │ │ │ +260 │ │ │ │ │ +261 template │ │ │ │ │ +_2_6_2 static constexpr bool hasStaticDegree = Std::is_detected::value; │ │ │ │ │ +263 │ │ │ │ │ +264 // accessor mixins need to be friends for access to proxiedNode() │ │ │ │ │ +265 friend class _S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s; │ │ │ │ │ +266 friend class _D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s; │ │ │ │ │ +267 │ │ │ │ │ +268 public: │ │ │ │ │ +269 │ │ │ │ │ +_2_7_0 typedef Node _P_r_o_x_i_e_d_N_o_d_e; │ │ │ │ │ +271 │ │ │ │ │ +_2_7_2 typedef _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_N_o_d_e_T_a_g_<_N_o_d_e_> _N_o_d_e_T_a_g; │ │ │ │ │ 273 │ │ │ │ │ -275 │ │ │ │ │ -276 } // namespace TypeTree │ │ │ │ │ -277} //namespace Dune │ │ │ │ │ -278 │ │ │ │ │ -279#endif // DUNE_TYPETREE_TRAVERSAL_HH │ │ │ │ │ -_v_i_s_i_t_o_r_._h_h │ │ │ │ │ -_t_r_e_e_p_a_t_h_._h_h │ │ │ │ │ -_c_h_i_l_d_e_x_t_r_a_c_t_i_o_n_._h_h │ │ │ │ │ +_2_7_5 static const bool _i_s_L_e_a_f = Node::isLeaf; │ │ │ │ │ +276 │ │ │ │ │ +_2_7_8 static const bool _i_s_P_o_w_e_r = Node::isPower; │ │ │ │ │ +279 │ │ │ │ │ +_2_8_1 static const bool _i_s_C_o_m_p_o_s_i_t_e = Node::isComposite; │ │ │ │ │ +282 │ │ │ │ │ +283 template , int> = 0> │ │ │ │ │ +_2_8_5 static constexpr auto _d_e_g_r_e_e () │ │ │ │ │ +286 { │ │ │ │ │ +287 return N::degree(); │ │ │ │ │ +288 } │ │ │ │ │ +289 │ │ │ │ │ +290 template , int> = 0> │ │ │ │ │ +_2_9_2 auto _d_e_g_r_e_e () const │ │ │ │ │ +293 { │ │ │ │ │ +294 return _p_r_o_x_i_e_d_N_o_d_e().degree(); │ │ │ │ │ +295 } │ │ │ │ │ +296 │ │ │ │ │ +297 │ │ │ │ │ +298 protected: │ │ │ │ │ +299 │ │ │ │ │ +302 │ │ │ │ │ +304 template │ │ │ │ │ +305 typename std::enable_if::type │ │ │ │ │ +_3_0_6 _p_r_o_x_i_e_d_N_o_d_e () │ │ │ │ │ +307 { │ │ │ │ │ +308 return *_node; │ │ │ │ │ +309 } │ │ │ │ │ +310 │ │ │ │ │ +_3_1_2 const Node& _p_r_o_x_i_e_d_N_o_d_e () const │ │ │ │ │ +313 { │ │ │ │ │ +314 return *_node; │ │ │ │ │ +315 } │ │ │ │ │ +316 │ │ │ │ │ +318 template │ │ │ │ │ +319 typename std::enable_if >::type │ │ │ │ │ +_3_2_0 _p_r_o_x_i_e_d_N_o_d_e_S_t_o_r_a_g_e () │ │ │ │ │ +321 { │ │ │ │ │ +322 return _node; │ │ │ │ │ +323 } │ │ │ │ │ +324 │ │ │ │ │ +_3_2_6 std::shared_ptr _p_r_o_x_i_e_d_N_o_d_e_S_t_o_r_a_g_e () const │ │ │ │ │ +327 { │ │ │ │ │ +328 return _node; │ │ │ │ │ +329 } │ │ │ │ │ +330 │ │ │ │ │ +332 │ │ │ │ │ +335 │ │ │ │ │ +_3_3_6 _P_r_o_x_y_N_o_d_e (Node& node) │ │ │ │ │ +337 : _node(stackobject_to_shared_ptr(node)) │ │ │ │ │ +338 {} │ │ │ │ │ +339 │ │ │ │ │ +_3_4_0 _P_r_o_x_y_N_o_d_e (std::shared_ptr node) │ │ │ │ │ +341 : _node(std::move(node)) │ │ │ │ │ +342 {} │ │ │ │ │ +343 │ │ │ │ │ +345 │ │ │ │ │ +346 private: │ │ │ │ │ +347 │ │ │ │ │ +348 std::shared_ptr _node; │ │ │ │ │ +349 }; │ │ │ │ │ +350 │ │ │ │ │ +352 │ │ │ │ │ +353 } // namespace TypeTree │ │ │ │ │ +354} //namespace Dune │ │ │ │ │ +355 │ │ │ │ │ +356#endif // DUNE_TYPETREE_PROXYNODE_HH │ │ │ │ │ _n_o_d_e_t_a_g_s_._h_h │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_o_r_E_a_c_h_N_o_d_e │ │ │ │ │ -void forEachNode(Tree &&tree, NodeFunc &&nodeFunc) │ │ │ │ │ -Traverse tree and visit each node. │ │ │ │ │ -DDeeffiinniittiioonn traversal.hh:254 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e │ │ │ │ │ -constexpr auto leafTreePathTuple() │ │ │ │ │ -Create tuple of tree paths to leafs. │ │ │ │ │ -DDeeffiinniittiioonn traversal.hh:218 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_f_o_r_E_a_c_h_L_e_a_f_N_o_d_e │ │ │ │ │ -void forEachLeafNode(Tree &&tree, LeafFunc &&leafFunc) │ │ │ │ │ -Traverse tree and visit each leaf node. │ │ │ │ │ -DDeeffiinniittiioonn traversal.hh:269 │ │ │ │ │ -_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_:_:_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_:_:_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 │ │ │ │ │ -_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 │ │ │ │ │ +_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h │ │ │ │ │ +_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 │ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_f_o_r_E_a_c_h_N_o_d_e │ │ │ │ │ -void forEachNode(T &&tree, TreePath treePath, PreFunc &&preFunc, LeafFunc │ │ │ │ │ -&&leafFunc, PostFunc &&postFunc) │ │ │ │ │ -DDeeffiinniittiioonn traversal.hh:164 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_D_y_n_a_m_i_c_T_r_a_v_e_r_s_a_l_C_o_n_c_e_p_t │ │ │ │ │ -decltype((std::declval< Tree >().degree(), std::declval< Tree >().child(0u))) │ │ │ │ │ -DynamicTraversalConcept │ │ │ │ │ -DDeeffiinniittiioonn traversal.hh:43 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_S_t_a_t_i_c_T_r_a_v_e_r_s_a_l_C_o_n_c_e_p_t │ │ │ │ │ -decltype((std::integral_constant< std::size_t, Tree::degree()>{})) │ │ │ │ │ -StaticTraversalConcept │ │ │ │ │ -DDeeffiinniittiioonn traversal.hh:49 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_a_p_p_l_y_T_o_T_r_e_e │ │ │ │ │ -void applyToTree(T &&tree, TreePath treePath, V &&visitor) │ │ │ │ │ -DDeeffiinniittiioonn traversal.hh:97 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_e_t_a_i_l_:_:_l_e_a_f_T_r_e_e_P_a_t_h_T_u_p_l_e │ │ │ │ │ -constexpr auto leafTreePathTuple(Prefix prefix) │ │ │ │ │ -DDeeffiinniittiioonn traversal.hh:54 │ │ │ │ │ -_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 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_L_e_a_f_N_o_d_e_T_a_g │ │ │ │ │ +Tag designating a leaf node. │ │ │ │ │ +DDeeffiinniittiioonn nodetags.hh:18 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_o_w_e_r_N_o_d_e_T_a_g │ │ │ │ │ +Tag designating a power node. │ │ │ │ │ +DDeeffiinniittiioonn nodetags.hh:21 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g │ │ │ │ │ +Tag designating a power node with runtime degree. │ │ │ │ │ +DDeeffiinniittiioonn nodetags.hh:24 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g │ │ │ │ │ +Tag designating a composite node. │ │ │ │ │ +DDeeffiinniittiioonn nodetags.hh:27 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e │ │ │ │ │ +Base class for nodes acting as a proxy for an existing node. │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:255 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_P_r_o_x_y_N_o_d_e │ │ │ │ │ +ProxyNode(Node &node) │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:336 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_N_o_d_e_T_a_g │ │ │ │ │ +Dune::TypeTree::NodeTag< Node > NodeTag │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:272 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_i_s_C_o_m_p_o_s_i_t_e │ │ │ │ │ +static const bool isComposite │ │ │ │ │ +Mark this class as a composite in the dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:281 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_i_s_L_e_a_f │ │ │ │ │ +static const bool isLeaf │ │ │ │ │ +Mark this class as non leaf in the dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:275 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_i_s_P_o_w_e_r │ │ │ │ │ +static const bool isPower │ │ │ │ │ +Mark this class as a non power in the dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:278 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_d_e_g_r_e_e │ │ │ │ │ +auto degree() const │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:292 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_p_r_o_x_i_e_d_N_o_d_e │ │ │ │ │ +std::enable_if< enabled, Node & >::type proxiedNode() │ │ │ │ │ +Returns the proxied node. │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:306 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_p_r_o_x_i_e_d_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ +std::shared_ptr< const Node > proxiedNodeStorage() const │ │ │ │ │ +Returns the storage of the proxied node (const version). │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:326 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_P_r_o_x_i_e_d_N_o_d_e │ │ │ │ │ +Node ProxiedNode │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:270 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_p_r_o_x_i_e_d_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ +std::enable_if< enabled, std::shared_ptr< Node > >::type proxiedNodeStorage() │ │ │ │ │ +Returns the storage of the proxied node. │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:320 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_d_e_g_r_e_e │ │ │ │ │ +static constexpr auto degree() │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:285 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_P_r_o_x_y_N_o_d_e │ │ │ │ │ +ProxyNode(std::shared_ptr< Node > node) │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:340 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_:_:_p_r_o_x_i_e_d_N_o_d_e │ │ │ │ │ +const Node & proxiedNode() const │ │ │ │ │ +Returns the proxied node (const version). │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:312 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s │ │ │ │ │ +Mixin class providing methods for child access with compile-time parameter. │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:30 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_c_h_i_l_d │ │ │ │ │ +auto & child(index_constant< k >={}) │ │ │ │ │ +Returns the i-th child. │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:71 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ +void setChild(ProxyChild &&child, typename std::enable_if< lazy_enabled< k >:: │ │ │ │ │ +value, void * >::type=0) │ │ │ │ │ +Sets the i-th child to the passed-in value. │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:112 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_n_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ +const ProxiedNode::NodeStorage & nodeStorage() const │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:117 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ +auto childStorage(index_constant< k >={}) │ │ │ │ │ +Returns the storage of the i-th child. │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:92 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_c_h_i_l_d │ │ │ │ │ +const auto & child(index_constant< k >={}) const │ │ │ │ │ +Returns the i-th child (const version). │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:81 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ +auto childStorage(index_constant< k >={}) const │ │ │ │ │ +Returns the storage of the i-th child (const version). │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:105 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_S_t_a_t_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_C_h_i_l_d │ │ │ │ │ +Access to the type and storage type of the i-th child. │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:60 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s │ │ │ │ │ +Mixin class providing methods for child access with run-time parameter. │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:133 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_c_h_i_l_d │ │ │ │ │ +auto & child(std::size_t i) │ │ │ │ │ +Returns the i-th child. │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:162 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ +auto childStorage(std::size_t i) const │ │ │ │ │ +Returns the storage of the i-th child (const version). │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:194 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ +void setChild(std::size_t i, ProxyChild &&child, typename std::enable_if< │ │ │ │ │ +enabled, void * >::type=0) │ │ │ │ │ +Sets the i-th child to the passed-in value. │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:201 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_c_h_i_l_d │ │ │ │ │ +const auto & child(std::size_t i) const │ │ │ │ │ +Returns the i-th child (const version). │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:171 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_D_y_n_a_m_i_c_C_h_i_l_d_A_c_c_e_s_s_o_r_s_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ +auto childStorage(std::size_t i) │ │ │ │ │ +Returns the storage of the i-th child. │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:182 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e │ │ │ │ │ +Tag-based dispatch to appropriate base class that provides necessary │ │ │ │ │ +functionality. │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:210 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g_ _>_:_:_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ +Node::NodeStorage NodeStorage │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:224 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g_ _>_:_:_C_h_i_l_d_T_y_p_e_s │ │ │ │ │ +Node::ChildTypes ChildTypes │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:223 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _P_o_w_e_r_N_o_d_e_T_a_g_ _>_:_:_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ +Node::NodeStorage NodeStorage │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:233 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _P_o_w_e_r_N_o_d_e_T_a_g_ _>_:_:_C_h_i_l_d_T_y_p_e │ │ │ │ │ +Node::ChildType ChildType │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:232 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g_ _>_:_:_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ +Node::NodeStorage NodeStorage │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:242 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_P_r_o_x_y_N_o_d_e_B_a_s_e_<_ _N_o_d_e_,_ _D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_a_g_ _>_:_:_C_h_i_l_d_T_y_p_e │ │ │ │ │ +Node::ChildType ChildType │ │ │ │ │ +DDeeffiinniittiioonn proxynode.hh:241 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00083.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: traversalutilities.hh File Reference │ │ │ │ +dune-typetree: filteredcompositenode.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -70,102 +70,46 @@ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    │ │ │ │ -Namespaces | │ │ │ │ -Functions
    │ │ │ │ -
    traversalutilities.hh File Reference
    │ │ │ │ +Classes | │ │ │ │ +Namespaces
    │ │ │ │ +
    filteredcompositenode.hh File Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ -
    #include <dune/typetree/traversal.hh>
    │ │ │ │ +
    #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>
    │ │ │ │
    │ │ │ │

    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...
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
     
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -

    │ │ │ │ -Functions

    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

    │ │ │ │ - │ │ │ │ -

    ◆ _functor

    │ │ │ │ - │ │ │ │ -
    │ │ │ │ -
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -
    F _functor
    │ │ │ │ -
    │ │ │ │ - │ │ │ │ -
    │ │ │ │ -
    │ │ │ │ - │ │ │ │ -

    ◆ _reduction

    │ │ │ │ - │ │ │ │ -
    │ │ │ │ -
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -
    R _reduction
    │ │ │ │ -
    │ │ │ │ - │ │ │ │ -
    │ │ │ │ -
    │ │ │ │ - │ │ │ │ -

    ◆ _value

    │ │ │ │ - │ │ │ │ -
    │ │ │ │ -
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -
    ResultType _value
    │ │ │ │ -
    │ │ │ │ - │ │ │ │ -
    │ │ │ │ -
    │ │ │ │ - │ │ │ │ -

    ◆ treePathType

    │ │ │ │ - │ │ │ │ -
    │ │ │ │ -
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │
    │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ -
    const TreePathType::Type treePathType = TreePathType::dynamic
    │ │ │ │ -     		│ │ │ │ -static
    │ │ │ │ -
    │ │ │ │ - │ │ │ │ -
    │ │ │ │ -
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,33 +1,32 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -_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> │ │ │ │ │ +_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s │ │ │ │ │ +filteredcompositenode.hh File Reference │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#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_/_f_i_l_t_e_r_s_._h_h> │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ +#include │ │ │ │ │ _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 │ │ │ │ │ + class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_<_ _N_o_d_e_,_ _F_i_l_t_e_r_ _> │ │ │ │ │ +  Base class for composite nodes representing a filtered view on an │ │ │ │ │ + underlying composite node. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_<_ _N_o_d_e_,_ _F_i_l_t_e_r_ _>_:_:_C_h_i_l_d_<_ _k_ _> │ │ │ │ │ +  Access to the type and storage type of the i-th child. _M_o_r_e_._._. │ │ │ │ │ +  │ │ │ │ │ NNaammeessppaacceess │ │ │ │ │ namespace   _D_u_n_e │ │ │ │ │   │ │ │ │ │ namespace   _D_u_n_e_:_:_T_y_p_e_T_r_e_e │ │ │ │ │   │ │ │ │ │ -FFuunnccttiioonnss │ │ │ │ │ -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 ********** │ │ │ │ │ -********** _?◆_? __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/a00083_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: traversalutilities.hh Source File │ │ │ │ +dune-typetree: filteredcompositenode.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,90 +74,287 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ -
    traversalutilities.hh
    │ │ │ │ +
    filteredcompositenode.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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_TRAVERSALUTILITIES_HH
    │ │ │ │ -
    7#define DUNE_TYPETREE_TRAVERSALUTILITIES_HH
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_FILTEREDCOMPOSITENODE_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_FILTEREDCOMPOSITENODE_HH
    │ │ │ │
    8
    │ │ │ │ -
    9#include <dune/typetree/traversal.hh>
    │ │ │ │ -
    10
    │ │ │ │ -
    11namespace Dune {
    │ │ │ │ -
    12 namespace TypeTree {
    │ │ │ │ -
    13
    │ │ │ │ -
    19 namespace {
    │ │ │ │ -
    20
    │ │ │ │ -
    22
    │ │ │ │ -
    27 template<typename F, typename R, typename ResultType>
    │ │ │ │ -
    28 struct LeafReductionVisitor
    │ │ │ │ -
    29 : public TypeTree::TreeVisitor
    │ │ │ │ -
    30 {
    │ │ │ │ -
    31
    │ │ │ │ -
    32 static const TreePathType::Type treePathType = TreePathType::dynamic;
    │ │ │ │ -
    33
    │ │ │ │ -
    34 template<typename Node, typename TreePath>
    │ │ │ │ -
    35 void leaf(const Node& node, TreePath treePath)
    │ │ │ │ -
    36 {
    │ │ │ │ -
    37 _value = _reduction(_value,_functor(node,treePath));
    │ │ │ │ -
    38 }
    │ │ │ │ -
    39
    │ │ │ │ -
    40 LeafReductionVisitor(F functor, R reduction, ResultType startValue)
    │ │ │ │ -
    41 : _functor(functor)
    │ │ │ │ -
    42 , _reduction(reduction)
    │ │ │ │ -
    43 , _value(startValue)
    │ │ │ │ -
    44 {}
    │ │ │ │ -
    45
    │ │ │ │ -
    46 ResultType result() { return _value; }
    │ │ │ │ -
    47
    │ │ │ │ -
    48 F _functor;
    │ │ │ │ -
    49 R _reduction;
    │ │ │ │ -
    50 ResultType _value;
    │ │ │ │ -
    51
    │ │ │ │ -
    52 };
    │ │ │ │ -
    53
    │ │ │ │ -
    54 } // anonymous namespace
    │ │ │ │ -
    55
    │ │ │ │ -
    57
    │ │ │ │ -
    82 template<typename ResultType, typename Tree, typename F, typename R>
    │ │ │ │ -
    │ │ │ │ -
    83 ResultType reduceOverLeafs(const Tree& tree, F functor, R reduction, ResultType startValue)
    │ │ │ │ -
    84 {
    │ │ │ │ -
    85 LeafReductionVisitor<F,R,ResultType> visitor(functor,reduction,startValue);
    │ │ │ │ -
    86 TypeTree::applyToTree(tree,visitor);
    │ │ │ │ -
    87 return visitor.result();
    │ │ │ │ -
    88 }
    │ │ │ │ -
    │ │ │ │ -
    89
    │ │ │ │ -
    91
    │ │ │ │ -
    92 } // namespace TypeTree
    │ │ │ │ -
    93} //namespace Dune
    │ │ │ │ -
    94
    │ │ │ │ -
    95#endif // DUNE_TYPETREE_TRAVERSALUTILITIES_HH
    │ │ │ │ -
    result
    static const result_type result
    Definition accumulate_static.hh:113
    │ │ │ │ - │ │ │ │ -
    _reduction
    R _reduction
    Definition traversalutilities.hh:49
    │ │ │ │ -
    _functor
    F _functor
    Definition traversalutilities.hh:48
    │ │ │ │ -
    treePathType
    static const TreePathType::Type treePathType
    Definition traversalutilities.hh:32
    │ │ │ │ -
    _value
    ResultType _value
    Definition traversalutilities.hh:50
    │ │ │ │ -
    Dune::TypeTree::reduceOverLeafs
    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
    │ │ │ │ -
    Dune::TypeTree::applyToTree
    void applyToTree(Tree &&tree, Visitor &&visitor)
    Apply visitor to TypeTree.
    Definition traversal.hh:239
    │ │ │ │ -
    Dune::TypeTree::treePath
    constexpr auto treePath(const T &... t)
    Constructs a new HybridTreePath from the given indices.
    Definition treepath.hh:326
    │ │ │ │ +
    9#include <memory>
    │ │ │ │ +
    10#include <tuple>
    │ │ │ │ +
    11#include <type_traits>
    │ │ │ │ +
    12
    │ │ │ │ +
    13#include <dune/typetree/nodetags.hh>
    │ │ │ │ +
    14#include <dune/typetree/filters.hh>
    │ │ │ │ +
    15#include <dune/common/shared_ptr.hh>
    │ │ │ │ +
    16#include <dune/common/typetraits.hh>
    │ │ │ │ +
    17#include <dune/common/indices.hh>
    │ │ │ │ +
    18
    │ │ │ │ +
    19#include <dune/typetree/filters.hh>
    │ │ │ │ +
    20#include <dune/typetree/nodetags.hh>
    │ │ │ │ +
    21
    │ │ │ │ +
    22namespace Dune {
    │ │ │ │ +
    23 namespace TypeTree {
    │ │ │ │ +
    24
    │ │ │ │ +
    30#ifndef DOXYGEN
    │ │ │ │ +
    31 namespace {
    │ │ │ │ +
    32
    │ │ │ │ +
    33 // ********************************************************************************
    │ │ │ │ +
    34 // Utility structs for filter construction and application
    │ │ │ │ +
    35 // ********************************************************************************
    │ │ │ │ +
    36
    │ │ │ │ +
    37 // Gets the filter and wraps it in case of a SimpleFilter.
    │ │ │ │ +
    38 template<typename Filter, typename Tag>
    │ │ │ │ +
    39 struct get_filter;
    │ │ │ │ +
    40
    │ │ │ │ +
    41 // Helper struct to extract the child template parameter pack from the ChildTypes tuple.
    │ │ │ │ +
    42 template<typename Filter, typename Node, typename ChildTypes>
    │ │ │ │ +
    43 struct apply_filter_wrapper;
    │ │ │ │ +
    44
    │ │ │ │ +
    45 template<typename Filter, typename Node, typename... Children>
    │ │ │ │ +
    46 struct apply_filter_wrapper<Filter,Node,std::tuple<Children...> >
    │ │ │ │ +
    47 : public Filter::template apply<Node,Children...>
    │ │ │ │ +
    48 {};
    │ │ │ │ +
    49
    │ │ │ │ +
    50 // specialization for SimpleFilter
    │ │ │ │ +
    51 template<typename Filter>
    │ │ │ │ +
    52 struct get_filter<Filter,SimpleFilterTag>
    │ │ │ │ +
    53 {
    │ │ │ │ +
    54 struct type
    │ │ │ │ +
    55 {
    │ │ │ │ +
    56 template<typename Node, typename ChildTypes>
    │ │ │ │ +
    57 struct apply
    │ │ │ │ +
    58 : public apply_filter_wrapper<filter<Filter>,Node,ChildTypes>
    │ │ │ │ +
    59 {};
    │ │ │ │ +
    60 };
    │ │ │ │ +
    61 };
    │ │ │ │ +
    62
    │ │ │ │ +
    63 // specialization for AdvancedFilter
    │ │ │ │ +
    64 template<typename Filter>
    │ │ │ │ +
    65 struct get_filter<Filter,AdvancedFilterTag>
    │ │ │ │ +
    66 {
    │ │ │ │ +
    67 struct type
    │ │ │ │ +
    68 {
    │ │ │ │ +
    69 template<typename Node, typename ChildTypes>
    │ │ │ │ +
    70 struct apply
    │ │ │ │ +
    71 : public apply_filter_wrapper<Filter,Node,ChildTypes>
    │ │ │ │ +
    72 {};
    │ │ │ │ +
    73 };
    │ │ │ │ +
    74 };
    │ │ │ │ +
    75
    │ │ │ │ +
    76 } // anonymous namespace
    │ │ │ │ +
    77#endif // DOXYGEN
    │ │ │ │ +
    78
    │ │ │ │ +
    79
    │ │ │ │ +
    81 template<typename Node, typename Filter>
    │ │ │ │ +
    │ │ │ │ +
    82 class FilteredCompositeNode
    │ │ │ │ +
    83 {
    │ │ │ │ +
    84
    │ │ │ │ +
    85 typedef typename get_filter<Filter,typename Filter::FilterTag>::type filter;
    │ │ │ │ +
    86 typedef typename filter::template apply<Node,typename Node::ChildTypes>::type filter_result;
    │ │ │ │ +
    87 typedef typename filter_result::template apply<Node> mapped_children;
    │ │ │ │ +
    88
    │ │ │ │ +
    89 static const bool nodeIsConst = std::is_const<typename std::remove_reference<Node>::type>::value;
    │ │ │ │ +
    90
    │ │ │ │ +
    91 template<std::size_t k>
    │ │ │ │ +
    92 struct lazy_enable
    │ │ │ │ +
    93 {
    │ │ │ │ +
    94 static const bool value = !nodeIsConst;
    │ │ │ │ +
    95 };
    │ │ │ │ +
    96
    │ │ │ │ +
    97 public:
    │ │ │ │ +
    98
    │ │ │ │ +
    100 typedef CompositeNodeTag NodeTag;
    │ │ │ │ +
    101
    │ │ │ │ +
    103 typedef typename mapped_children::NodeStorage NodeStorage;
    │ │ │ │ +
    104
    │ │ │ │ +
    106 typedef typename mapped_children::ChildTypes ChildTypes;
    │ │ │ │ +
    107
    │ │ │ │ +
    109 static const bool isLeaf = false;
    │ │ │ │ +
    110
    │ │ │ │ +
    112 static const bool isPower = false;
    │ │ │ │ +
    113
    │ │ │ │ +
    115 static const bool isComposite = true;
    │ │ │ │ +
    116
    │ │ │ │ +
    │ │ │ │ +
    117 static constexpr auto degree ()
    │ │ │ │ +
    118 {
    │ │ │ │ +
    119 return std::integral_constant<std::size_t,filter_result::size>{};
    │ │ │ │ +
    120 }
    │ │ │ │ +
    │ │ │ │ +
    121
    │ │ │ │ +
    123 template<std::size_t k>
    │ │ │ │ +
    │ │ │ │ +
    124 struct Child {
    │ │ │ │ +
    125
    │ │ │ │ +
    126#ifndef DOXYGEN
    │ │ │ │ +
    127
    │ │ │ │ +
    128 typedef typename std::tuple_element<k,typename mapped_children::Children>::type OriginalChild;
    │ │ │ │ +
    129
    │ │ │ │ +
    130 static const std::size_t mapped_index = std::tuple_element<k,typename filter_result::IndexMap>::type::original_index;
    │ │ │ │ +
    131
    │ │ │ │ +
    132#endif // DOXYGEN
    │ │ │ │ +
    133
    │ │ │ │ +
    135 typedef typename OriginalChild::Type Type;
    │ │ │ │ +
    136
    │ │ │ │ +
    138 typedef typename OriginalChild::type type;
    │ │ │ │ +
    139 };
    │ │ │ │ +
    │ │ │ │ +
    140
    │ │ │ │ +
    143
    │ │ │ │ +
    145
    │ │ │ │ +
    148 template<std::size_t k,
    │ │ │ │ +
    149 typename std::enable_if<lazy_enable<k>::value, int>::type = 0>
    │ │ │ │ +
    │ │ │ │ +
    150 auto& child (index_constant<k> = {})
    │ │ │ │ +
    151 {
    │ │ │ │ +
    152 return _node->template child<Child<k>::mapped_index>();
    │ │ │ │ +
    153 }
    │ │ │ │ +
    │ │ │ │ +
    154
    │ │ │ │ +
    156
    │ │ │ │ +
    159 template<std::size_t k>
    │ │ │ │ +
    │ │ │ │ +
    160 const auto& child (index_constant<k> = {}) const
    │ │ │ │ +
    161 {
    │ │ │ │ +
    162 return _node->template child<Child<k>::mapped_index>();
    │ │ │ │ +
    163 }
    │ │ │ │ +
    │ │ │ │ +
    164
    │ │ │ │ +
    166
    │ │ │ │ +
    169 template<std::size_t k,
    │ │ │ │ +
    170 typename std::enable_if<lazy_enable<k>::value, int>::type = 0>
    │ │ │ │ +
    │ │ │ │ +
    171 auto childStorage (index_constant<k> = {})
    │ │ │ │ +
    172 {
    │ │ │ │ +
    173 return _node->template childStorage<Child<k>::mapped_index>();
    │ │ │ │ +
    174 }
    │ │ │ │ +
    │ │ │ │ +
    175
    │ │ │ │ +
    177
    │ │ │ │ +
    180 template<std::size_t k>
    │ │ │ │ +
    │ │ │ │ +
    181 auto childStorage (index_constant<k> = {}) const
    │ │ │ │ +
    182 {
    │ │ │ │ +
    183 return _node->template childStorage<Child<k>::mapped_index>();
    │ │ │ │ +
    184 }
    │ │ │ │ +
    │ │ │ │ +
    185
    │ │ │ │ +
    187 template<std::size_t k, class ChildType>
    │ │ │ │ +
    │ │ │ │ +
    188 void setChild (ChildType&& child, typename std::enable_if<lazy_enable<k>::value,void*>::type = 0)
    │ │ │ │ +
    189 {
    │ │ │ │ +
    190 _node->template setChild<Child<k>::mapped_index>(std::forward<ChildType>(child));
    │ │ │ │ +
    191 }
    │ │ │ │ +
    │ │ │ │ +
    192
    │ │ │ │ +
    194
    │ │ │ │ +
    197
    │ │ │ │ +
    198 protected:
    │ │ │ │ +
    199
    │ │ │ │ +
    201
    │ │ │ │ +
    204 template<bool enabled = !nodeIsConst>
    │ │ │ │ +
    205 typename std::enable_if<enabled,Node&>::type
    │ │ │ │ +
    │ │ │ │ +
    206 unfiltered ()
    │ │ │ │ +
    207 {
    │ │ │ │ +
    208 return *_node;
    │ │ │ │ +
    209 }
    │ │ │ │ +
    │ │ │ │ +
    210
    │ │ │ │ +
    212
    │ │ │ │ +
    │ │ │ │ +
    215 const Node& unfiltered () const
    │ │ │ │ +
    216 {
    │ │ │ │ +
    217 return *_node;
    │ │ │ │ +
    218 }
    │ │ │ │ +
    │ │ │ │ +
    219
    │ │ │ │ +
    221
    │ │ │ │ +
    224 template<bool enabled = !nodeIsConst>
    │ │ │ │ +
    225 typename std::enable_if<enabled,std::shared_ptr<Node> >::type
    │ │ │ │ +
    │ │ │ │ +
    226 unfilteredStorage ()
    │ │ │ │ +
    227 {
    │ │ │ │ +
    228 return _node;
    │ │ │ │ +
    229 }
    │ │ │ │ +
    │ │ │ │ +
    230
    │ │ │ │ +
    232
    │ │ │ │ +
    │ │ │ │ +
    235 std::shared_ptr<const Node> unfilteredStorage () const
    │ │ │ │ +
    236 {
    │ │ │ │ +
    237 return _node;
    │ │ │ │ +
    238 }
    │ │ │ │ +
    │ │ │ │ +
    239
    │ │ │ │ +
    241
    │ │ │ │ +
    242 public:
    │ │ │ │ +
    243
    │ │ │ │ +
    246
    │ │ │ │ +
    │ │ │ │ +
    248 FilteredCompositeNode (std::shared_ptr<Node> node)
    │ │ │ │ +
    249 : _node(std::move(node))
    │ │ │ │ +
    250 {}
    │ │ │ │ +
    │ │ │ │ +
    251
    │ │ │ │ +
    │ │ │ │ +
    253 FilteredCompositeNode (Node& node)
    │ │ │ │ +
    254 : _node(stackobject_to_shared_ptr(node))
    │ │ │ │ +
    255 {}
    │ │ │ │ +
    │ │ │ │ +
    256
    │ │ │ │ +
    258
    │ │ │ │ +
    259 private:
    │ │ │ │ +
    260 std::shared_ptr<Node> _node;
    │ │ │ │ +
    261 };
    │ │ │ │ +
    │ │ │ │ +
    262
    │ │ │ │ +
    264
    │ │ │ │ +
    265 } // namespace TypeTree
    │ │ │ │ +
    266} //namespace Dune
    │ │ │ │ +
    267
    │ │ │ │ +
    268#endif // DUNE_TYPETREE_FILTEREDCOMPOSITENODE_HH
    │ │ │ │ + │ │ │ │ + │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::TreePathType::Type
    Type
    Definition treepath.hh:106
    │ │ │ │ -
    Dune::TypeTree::TreePathType::dynamic
    @ dynamic
    Definition treepath.hh:106
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode
    Base class for composite nodes representing a filtered view on an underlying composite node.
    Definition filteredcompositenode.hh:83
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::childStorage
    auto childStorage(index_constant< k >={}) const
    Returns the storage of the k-th child (const version).
    Definition filteredcompositenode.hh:181
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::degree
    static constexpr auto degree()
    Definition filteredcompositenode.hh:117
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::NodeStorage
    mapped_children::NodeStorage NodeStorage
    The type used for storing the children.
    Definition filteredcompositenode.hh:103
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::setChild
    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
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::isLeaf
    static const bool isLeaf
    Mark this class as non leaf in the dune-typetree.
    Definition filteredcompositenode.hh:109
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::unfiltered
    const Node & unfiltered() const
    Returns the unfiltered node (const version).
    Definition filteredcompositenode.hh:215
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::isComposite
    static const bool isComposite
    Mark this class as a composite in the dune-typetree.
    Definition filteredcompositenode.hh:115
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::unfilteredStorage
    std::enable_if< enabled, std::shared_ptr< Node > >::type unfilteredStorage()
    Returns the storage object of the unfiltered node.
    Definition filteredcompositenode.hh:226
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::isPower
    static const bool isPower
    Mark this class as a non power in the dune-typetree.
    Definition filteredcompositenode.hh:112
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::FilteredCompositeNode
    FilteredCompositeNode(Node &node)
    Initialize the CompositeNode with a copy of the passed-in storage type.
    Definition filteredcompositenode.hh:253
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::FilteredCompositeNode
    FilteredCompositeNode(std::shared_ptr< Node > node)
    Initialize the CompositeNode with copies of the passed in Storage objects.
    Definition filteredcompositenode.hh:248
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::childStorage
    auto childStorage(index_constant< k >={})
    Returns the storage of the k-th child.
    Definition filteredcompositenode.hh:171
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::child
    const auto & child(index_constant< k >={}) const
    Returns the k-th child (const version).
    Definition filteredcompositenode.hh:160
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::child
    auto & child(index_constant< k >={})
    Returns the k-th child.
    Definition filteredcompositenode.hh:150
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::NodeTag
    CompositeNodeTag NodeTag
    The type tag that describes a CompositeNode.
    Definition filteredcompositenode.hh:100
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::ChildTypes
    mapped_children::ChildTypes ChildTypes
    A tuple storing the types of all children.
    Definition filteredcompositenode.hh:106
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::unfiltered
    std::enable_if< enabled, Node & >::type unfiltered()
    Returns the unfiltered node.
    Definition filteredcompositenode.hh:206
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::unfilteredStorage
    std::shared_ptr< const Node > unfilteredStorage() const
    Returns the storage object of the unfiltered node (const version).
    Definition filteredcompositenode.hh:235
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::Child
    Access to the type and storage type of the i-th child.
    Definition filteredcompositenode.hh:124
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::Child::type
    OriginalChild::type type
    The type of the child.
    Definition filteredcompositenode.hh:138
    │ │ │ │ +
    Dune::TypeTree::FilteredCompositeNode::Child::Type
    OriginalChild::Type Type
    The type of the child.
    Definition filteredcompositenode.hh:135
    │ │ │ │ +
    Dune::TypeTree::CompositeNodeTag
    Tag designating a composite node.
    Definition nodetags.hh:27
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,109 +1,333 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -traversalutilities.hh │ │ │ │ │ +filteredcompositenode.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_TRAVERSALUTILITIES_HH │ │ │ │ │ -7#define DUNE_TYPETREE_TRAVERSALUTILITIES_HH │ │ │ │ │ +6#ifndef DUNE_TYPETREE_FILTEREDCOMPOSITENODE_HH │ │ │ │ │ +7#define DUNE_TYPETREE_FILTEREDCOMPOSITENODE_HH │ │ │ │ │ 8 │ │ │ │ │ -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 { │ │ │ │ │ -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 │ │ │ │ │ -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 │ │ │ │ │ -92 } // namespace TypeTree │ │ │ │ │ -93} //namespace Dune │ │ │ │ │ -94 │ │ │ │ │ -95#endif // DUNE_TYPETREE_TRAVERSALUTILITIES_HH │ │ │ │ │ -_r_e_s_u_l_t │ │ │ │ │ -static const result_type result │ │ │ │ │ -DDeeffiinniittiioonn accumulate_static.hh:113 │ │ │ │ │ -_t_r_a_v_e_r_s_a_l_._h_h │ │ │ │ │ -___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 │ │ │ │ │ -_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 │ │ │ │ │ +9#include │ │ │ │ │ +10#include │ │ │ │ │ +11#include │ │ │ │ │ +12 │ │ │ │ │ +13#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ +14#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_f_i_l_t_e_r_s_._h_h> │ │ │ │ │ +15#include │ │ │ │ │ +16#include │ │ │ │ │ +17#include │ │ │ │ │ +18 │ │ │ │ │ +19#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_f_i_l_t_e_r_s_._h_h> │ │ │ │ │ +20#include <_d_u_n_e_/_t_y_p_e_t_r_e_e_/_n_o_d_e_t_a_g_s_._h_h> │ │ │ │ │ +21 │ │ │ │ │ +22namespace _D_u_n_e { │ │ │ │ │ +23 namespace TypeTree { │ │ │ │ │ +24 │ │ │ │ │ +30#ifndef DOXYGEN │ │ │ │ │ +31 namespace { │ │ │ │ │ +32 │ │ │ │ │ +33 / │ │ │ │ │ +/ │ │ │ │ │ +******************************************************************************** │ │ │ │ │ +34 // Utility structs for filter construction and application │ │ │ │ │ +35 / │ │ │ │ │ +/ │ │ │ │ │ +******************************************************************************** │ │ │ │ │ +36 │ │ │ │ │ +37 // Gets the filter and wraps it in case of a SimpleFilter. │ │ │ │ │ +38 template │ │ │ │ │ +39 struct get_filter; │ │ │ │ │ +40 │ │ │ │ │ +41 // Helper struct to extract the child template parameter pack from the │ │ │ │ │ +ChildTypes tuple. │ │ │ │ │ +42 template │ │ │ │ │ +43 struct apply_filter_wrapper; │ │ │ │ │ +44 │ │ │ │ │ +45 template │ │ │ │ │ +46 struct apply_filter_wrapper > │ │ │ │ │ +47 : public Filter::template apply │ │ │ │ │ +48 {}; │ │ │ │ │ +49 │ │ │ │ │ +50 // specialization for SimpleFilter │ │ │ │ │ +51 template │ │ │ │ │ +52 struct get_filter │ │ │ │ │ +53 { │ │ │ │ │ +54 struct type │ │ │ │ │ +55 { │ │ │ │ │ +56 template │ │ │ │ │ +57 struct apply │ │ │ │ │ +58 : public apply_filter_wrapper,Node,ChildTypes> │ │ │ │ │ +59 {}; │ │ │ │ │ +60 }; │ │ │ │ │ +61 }; │ │ │ │ │ +62 │ │ │ │ │ +63 // specialization for AdvancedFilter │ │ │ │ │ +64 template │ │ │ │ │ +65 struct get_filter │ │ │ │ │ +66 { │ │ │ │ │ +67 struct type │ │ │ │ │ +68 { │ │ │ │ │ +69 template │ │ │ │ │ +70 struct apply │ │ │ │ │ +71 : public apply_filter_wrapper │ │ │ │ │ +72 {}; │ │ │ │ │ +73 }; │ │ │ │ │ +74 }; │ │ │ │ │ +75 │ │ │ │ │ +76 } // anonymous namespace │ │ │ │ │ +77#endif // DOXYGEN │ │ │ │ │ +78 │ │ │ │ │ +79 │ │ │ │ │ +81 template │ │ │ │ │ +_8_2 class _F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e │ │ │ │ │ +83 { │ │ │ │ │ +84 │ │ │ │ │ +85 typedef typename get_filter::type filter; │ │ │ │ │ +86 typedef typename filter::template apply:: │ │ │ │ │ +type filter_result; │ │ │ │ │ +87 typedef typename filter_result::template apply mapped_children; │ │ │ │ │ +88 │ │ │ │ │ +89 static const bool nodeIsConst = std::is_const::type>::value; │ │ │ │ │ +90 │ │ │ │ │ +91 template │ │ │ │ │ +92 struct lazy_enable │ │ │ │ │ +93 { │ │ │ │ │ +94 static const bool value = !nodeIsConst; │ │ │ │ │ +95 }; │ │ │ │ │ +96 │ │ │ │ │ +97 public: │ │ │ │ │ +98 │ │ │ │ │ +_1_0_0 typedef _C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g _N_o_d_e_T_a_g; │ │ │ │ │ +101 │ │ │ │ │ +_1_0_3 typedef typename mapped_children::NodeStorage _N_o_d_e_S_t_o_r_a_g_e; │ │ │ │ │ +104 │ │ │ │ │ +_1_0_6 typedef typename mapped_children::ChildTypes _C_h_i_l_d_T_y_p_e_s; │ │ │ │ │ +107 │ │ │ │ │ +_1_0_9 static const bool _i_s_L_e_a_f = false; │ │ │ │ │ +110 │ │ │ │ │ +_1_1_2 static const bool _i_s_P_o_w_e_r = false; │ │ │ │ │ +113 │ │ │ │ │ +_1_1_5 static const bool _i_s_C_o_m_p_o_s_i_t_e = true; │ │ │ │ │ +116 │ │ │ │ │ +_1_1_7 static constexpr auto _d_e_g_r_e_e () │ │ │ │ │ +118 { │ │ │ │ │ +119 return std::integral_constant{}; │ │ │ │ │ +120 } │ │ │ │ │ +121 │ │ │ │ │ +123 template │ │ │ │ │ +_1_2_4 struct _C_h_i_l_d { │ │ │ │ │ +125 │ │ │ │ │ +126#ifndef DOXYGEN │ │ │ │ │ +127 │ │ │ │ │ +128 typedef typename std::tuple_element:: │ │ │ │ │ +type OriginalChild; │ │ │ │ │ +129 │ │ │ │ │ +130 static const std::size_t mapped_index = std::tuple_element::type::original_index; │ │ │ │ │ +131 │ │ │ │ │ +132#endif // DOXYGEN │ │ │ │ │ +133 │ │ │ │ │ +_1_3_5 typedef typename OriginalChild::Type _T_y_p_e; │ │ │ │ │ +136 │ │ │ │ │ +_1_3_8 typedef typename OriginalChild::type _t_y_p_e; │ │ │ │ │ +139 }; │ │ │ │ │ +140 │ │ │ │ │ +143 │ │ │ │ │ +145 │ │ │ │ │ +148 template::value, int>::type = 0> │ │ │ │ │ +_1_5_0 auto& _c_h_i_l_d (index_constant = {}) │ │ │ │ │ +151 { │ │ │ │ │ +152 return _node->template child::mapped_index>(); │ │ │ │ │ +153 } │ │ │ │ │ +154 │ │ │ │ │ +156 │ │ │ │ │ +159 template │ │ │ │ │ +_1_6_0 const auto& _c_h_i_l_d (index_constant = {}) const │ │ │ │ │ +161 { │ │ │ │ │ +162 return _node->template child::mapped_index>(); │ │ │ │ │ +163 } │ │ │ │ │ +164 │ │ │ │ │ +166 │ │ │ │ │ +169 template::value, int>::type = 0> │ │ │ │ │ +_1_7_1 auto _c_h_i_l_d_S_t_o_r_a_g_e (index_constant = {}) │ │ │ │ │ +172 { │ │ │ │ │ +173 return _node->template childStorage::mapped_index>(); │ │ │ │ │ +174 } │ │ │ │ │ +175 │ │ │ │ │ +177 │ │ │ │ │ +180 template │ │ │ │ │ +_1_8_1 auto _c_h_i_l_d_S_t_o_r_a_g_e (index_constant = {}) const │ │ │ │ │ +182 { │ │ │ │ │ +183 return _node->template childStorage::mapped_index>(); │ │ │ │ │ +184 } │ │ │ │ │ +185 │ │ │ │ │ +187 template │ │ │ │ │ +_1_8_8 void _s_e_t_C_h_i_l_d (ChildType&& _c_h_i_l_d, typename std::enable_if:: │ │ │ │ │ +value,void*>::type = 0) │ │ │ │ │ +189 { │ │ │ │ │ +190 _node->template setChild::mapped_index>(std::forward │ │ │ │ │ +(_c_h_i_l_d)); │ │ │ │ │ +191 } │ │ │ │ │ +192 │ │ │ │ │ +194 │ │ │ │ │ +197 │ │ │ │ │ +198 protected: │ │ │ │ │ +199 │ │ │ │ │ +201 │ │ │ │ │ +204 template │ │ │ │ │ +205 typename std::enable_if::type │ │ │ │ │ +_2_0_6 _u_n_f_i_l_t_e_r_e_d () │ │ │ │ │ +207 { │ │ │ │ │ +208 return *_node; │ │ │ │ │ +209 } │ │ │ │ │ +210 │ │ │ │ │ +212 │ │ │ │ │ +_2_1_5 const Node& _u_n_f_i_l_t_e_r_e_d () const │ │ │ │ │ +216 { │ │ │ │ │ +217 return *_node; │ │ │ │ │ +218 } │ │ │ │ │ +219 │ │ │ │ │ +221 │ │ │ │ │ +224 template │ │ │ │ │ +225 typename std::enable_if >::type │ │ │ │ │ +_2_2_6 _u_n_f_i_l_t_e_r_e_d_S_t_o_r_a_g_e () │ │ │ │ │ +227 { │ │ │ │ │ +228 return _node; │ │ │ │ │ +229 } │ │ │ │ │ +230 │ │ │ │ │ +232 │ │ │ │ │ +_2_3_5 std::shared_ptr _u_n_f_i_l_t_e_r_e_d_S_t_o_r_a_g_e () const │ │ │ │ │ +236 { │ │ │ │ │ +237 return _node; │ │ │ │ │ +238 } │ │ │ │ │ +239 │ │ │ │ │ +241 │ │ │ │ │ +242 public: │ │ │ │ │ +243 │ │ │ │ │ +246 │ │ │ │ │ +_2_4_8 _F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e (std::shared_ptr node) │ │ │ │ │ +249 : _node(std::move(node)) │ │ │ │ │ +250 {} │ │ │ │ │ +251 │ │ │ │ │ +_2_5_3 _F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e (Node& node) │ │ │ │ │ +254 : _node(stackobject_to_shared_ptr(node)) │ │ │ │ │ +255 {} │ │ │ │ │ +256 │ │ │ │ │ +258 │ │ │ │ │ +259 private: │ │ │ │ │ +260 std::shared_ptr _node; │ │ │ │ │ +261 }; │ │ │ │ │ +262 │ │ │ │ │ +264 │ │ │ │ │ +265 } // namespace TypeTree │ │ │ │ │ +266} //namespace Dune │ │ │ │ │ +267 │ │ │ │ │ +268#endif // DUNE_TYPETREE_FILTEREDCOMPOSITENODE_HH │ │ │ │ │ +_f_i_l_t_e_r_s_._h_h │ │ │ │ │ +_n_o_d_e_t_a_g_s_._h_h │ │ │ │ │ _D_u_n_e │ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_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 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e │ │ │ │ │ +Base class for composite nodes representing a filtered view on an underlying │ │ │ │ │ +composite node. │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:83 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ +auto childStorage(index_constant< k >={}) const │ │ │ │ │ +Returns the storage of the k-th child (const version). │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:181 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_d_e_g_r_e_e │ │ │ │ │ +static constexpr auto degree() │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:117 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_N_o_d_e_S_t_o_r_a_g_e │ │ │ │ │ +mapped_children::NodeStorage NodeStorage │ │ │ │ │ +The type used for storing the children. │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:103 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_s_e_t_C_h_i_l_d │ │ │ │ │ +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. │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:188 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_i_s_L_e_a_f │ │ │ │ │ +static const bool isLeaf │ │ │ │ │ +Mark this class as non leaf in the dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:109 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_u_n_f_i_l_t_e_r_e_d │ │ │ │ │ +const Node & unfiltered() const │ │ │ │ │ +Returns the unfiltered node (const version). │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:215 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_i_s_C_o_m_p_o_s_i_t_e │ │ │ │ │ +static const bool isComposite │ │ │ │ │ +Mark this class as a composite in the dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:115 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_u_n_f_i_l_t_e_r_e_d_S_t_o_r_a_g_e │ │ │ │ │ +std::enable_if< enabled, std::shared_ptr< Node > >::type unfilteredStorage() │ │ │ │ │ +Returns the storage object of the unfiltered node. │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:226 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_i_s_P_o_w_e_r │ │ │ │ │ +static const bool isPower │ │ │ │ │ +Mark this class as a non power in the dune-typetree. │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:112 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e │ │ │ │ │ +FilteredCompositeNode(Node &node) │ │ │ │ │ +Initialize the CompositeNode with a copy of the passed-in storage type. │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:253 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e │ │ │ │ │ +FilteredCompositeNode(std::shared_ptr< Node > node) │ │ │ │ │ +Initialize the CompositeNode with copies of the passed in Storage objects. │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:248 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d_S_t_o_r_a_g_e │ │ │ │ │ +auto childStorage(index_constant< k >={}) │ │ │ │ │ +Returns the storage of the k-th child. │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:171 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ +const auto & child(index_constant< k >={}) const │ │ │ │ │ +Returns the k-th child (const version). │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:160 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_c_h_i_l_d │ │ │ │ │ +auto & child(index_constant< k >={}) │ │ │ │ │ +Returns the k-th child. │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:150 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_N_o_d_e_T_a_g │ │ │ │ │ +CompositeNodeTag NodeTag │ │ │ │ │ +The type tag that describes a CompositeNode. │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:100 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_h_i_l_d_T_y_p_e_s │ │ │ │ │ +mapped_children::ChildTypes ChildTypes │ │ │ │ │ +A tuple storing the types of all children. │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:106 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_u_n_f_i_l_t_e_r_e_d │ │ │ │ │ +std::enable_if< enabled, Node & >::type unfiltered() │ │ │ │ │ +Returns the unfiltered node. │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:206 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_u_n_f_i_l_t_e_r_e_d_S_t_o_r_a_g_e │ │ │ │ │ +std::shared_ptr< const Node > unfilteredStorage() const │ │ │ │ │ +Returns the storage object of the unfiltered node (const version). │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:235 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_h_i_l_d │ │ │ │ │ +Access to the type and storage type of the i-th child. │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:124 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_h_i_l_d_:_:_t_y_p_e │ │ │ │ │ +OriginalChild::type type │ │ │ │ │ +The type of the child. │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:138 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_F_i_l_t_e_r_e_d_C_o_m_p_o_s_i_t_e_N_o_d_e_:_:_C_h_i_l_d_:_:_T_y_p_e │ │ │ │ │ +OriginalChild::Type Type │ │ │ │ │ +The type of the child. │ │ │ │ │ +DDeeffiinniittiioonn filteredcompositenode.hh:135 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_C_o_m_p_o_s_i_t_e_N_o_d_e_T_a_g │ │ │ │ │ +Tag designating a composite node. │ │ │ │ │ +DDeeffiinniittiioonn nodetags.hh:27 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00086.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: exceptions.hh File Reference │ │ │ │ +dune-typetree: powercompositenodetransformationtemplates.hh File Reference │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -72,39 +72,44 @@ │ │ │ │
  • dune
  • typetree
    • │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │ Classes | │ │ │ │ Namespaces
    │ │ │ │ -
    exceptions.hh File Reference
    │ │ │ │ +
    powercompositenodetransformationtemplates.hh File Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │ - │ │ │ │ -

    TypeTree-specific exceptions. │ │ │ │ -More...

    │ │ │ │ -
    #include <dune/common/exceptions.hh>
    │ │ │ │ +
    #include <cstddef>
    │ │ │ │ +#include <dune/typetree/nodeinterface.hh>
    │ │ │ │
    │ │ │ │

    Go to the source code of this file.

    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    class  Dune::TypeTree::Exception
     Base class for all TypeTree exceptions. More...
    struct  Dune::TypeTree::GenericPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >
     
    struct  Dune::TypeTree::GenericPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::result< TC >
     
    struct  Dune::TypeTree::GenericDynamicPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >
     
    struct  Dune::TypeTree::GenericDynamicPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::result< TC >
     
    struct  Dune::TypeTree::GenericCompositeNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >
     
    struct  Dune::TypeTree::GenericCompositeNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::result< TC >
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Namespaces

    namespace  Dune
     
    namespace  Dune::TypeTree
     
    │ │ │ │ -

    Detailed Description

    │ │ │ │ -

    TypeTree-specific exceptions.

    │ │ │ │ -
    │ │ │ │ +
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,24 +1,37 @@ │ │ │ │ │ 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 │ │ │ │ │ -exceptions.hh File Reference │ │ │ │ │ -TypeTree-specific exceptions. _M_o_r_e_._._. │ │ │ │ │ -#include │ │ │ │ │ +powercompositenodetransformationtemplates.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> │ │ │ │ │ _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 │ │ │ │ │ -class   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_c_e_p_t_i_o_n │ │ │ │ │ -  Base class for all _T_y_p_e_T_r_e_e exceptions. _M_o_r_e_._._. │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ + _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_<_ _S_o_u_r_c_e_N_o_d_e_, │ │ │ │ │ + _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _>_:_:_r_e_s_u_l_t_<_ _T_C_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_< │ │ │ │ │ + _S_o_u_r_c_e_N_o_d_e_,_ _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_< │ │ │ │ │ + _S_o_u_r_c_e_N_o_d_e_,_ _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _>_:_:_r_e_s_u_l_t_<_ _T_C_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_< │ │ │ │ │ + _S_o_u_r_c_e_N_o_d_e_,_ _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _> │ │ │ │ │ +  │ │ │ │ │ +struct   _D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_< │ │ │ │ │ + _S_o_u_r_c_e_N_o_d_e_,_ _T_r_a_n_s_f_o_r_m_a_t_i_o_n_,_ _T_r_a_n_s_f_o_r_m_e_d_N_o_d_e_ _>_:_:_r_e_s_u_l_t_<_ _T_C_ _> │ │ │ │ │   │ │ │ │ │ NNaammeessppaacceess │ │ │ │ │ namespace   _D_u_n_e │ │ │ │ │   │ │ │ │ │ namespace   _D_u_n_e_:_:_T_y_p_e_T_r_e_e │ │ │ │ │   │ │ │ │ │ -********** DDeettaaiilleedd DDeessccrriippttiioonn ********** │ │ │ │ │ -TypeTree-specific exceptions. │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00086_source.html │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ -dune-typetree: exceptions.hh Source File │ │ │ │ +dune-typetree: powercompositenodetransformationtemplates.hh Source File │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -74,41 +74,91 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ -
    exceptions.hh
    │ │ │ │ +
    powercompositenodetransformationtemplates.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ Go to the documentation of this file.
    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#ifndef DUNE_TYPETREE_EXCEPTIONS_HH
    │ │ │ │ -
    6#define DUNE_TYPETREE_EXCEPTIONS_HH
    │ │ │ │ -
    7
    │ │ │ │ -
    8#include <dune/common/exceptions.hh>
    │ │ │ │ -
    9
    │ │ │ │ -
    15namespace Dune {
    │ │ │ │ -
    16 namespace TypeTree {
    │ │ │ │ -
    17
    │ │ │ │ -
    │ │ │ │ -
    19 class Exception
    │ │ │ │ -
    20 : public Dune::Exception
    │ │ │ │ -
    21 {};
    │ │ │ │ -
    │ │ │ │ -
    22
    │ │ │ │ -
    23 } // namespace TypeTree
    │ │ │ │ -
    24} // namespace Dune
    │ │ │ │ -
    25
    │ │ │ │ -
    26#endif // DUNE_TYPETREE_EXCEPTIONS_HH
    │ │ │ │ +
    5
    │ │ │ │ +
    6#ifndef DUNE_TYPETREE_POWERCOMPOSITENODETRANSFORMATIONTEMPLATES_HH
    │ │ │ │ +
    7#define DUNE_TYPETREE_POWERCOMPOSITENODETRANSFORMATIONTEMPLATES_HH
    │ │ │ │ +
    8
    │ │ │ │ +
    9#include <cstddef>
    │ │ │ │ +
    10
    │ │ │ │ +
    11#include <dune/typetree/nodeinterface.hh>
    │ │ │ │ +
    12
    │ │ │ │ +
    13namespace Dune {
    │ │ │ │ +
    14 namespace TypeTree {
    │ │ │ │ +
    15
    │ │ │ │ +
    21 template<typename SourceNode, typename Transformation, template<typename,typename,std::size_t> class TransformedNode>
    │ │ │ │ +
    │ │ │ │ +
    22 struct GenericPowerNodeTransformationTemplate
    │ │ │ │ +
    23 {
    │ │ │ │ +
    24 template<typename TC>
    │ │ │ │ +
    │ │ │ │ +
    25 struct result
    │ │ │ │ +
    26 {
    │ │ │ │ +
    27 typedef TransformedNode<SourceNode,TC,StaticDegree<SourceNode>::value> type;
    │ │ │ │ +
    28 };
    │ │ │ │ +
    │ │ │ │ +
    29 };
    │ │ │ │ +
    │ │ │ │ +
    30
    │ │ │ │ +
    31
    │ │ │ │ +
    32 template<typename SourceNode, typename Transformation, template<typename,typename> class TransformedNode>
    │ │ │ │ +
    │ │ │ │ +
    33 struct GenericDynamicPowerNodeTransformationTemplate
    │ │ │ │ +
    34 {
    │ │ │ │ +
    35 template<typename TC>
    │ │ │ │ +
    │ │ │ │ +
    36 struct result
    │ │ │ │ +
    37 {
    │ │ │ │ +
    38 typedef TransformedNode<SourceNode,TC> type;
    │ │ │ │ +
    39 };
    │ │ │ │ +
    │ │ │ │ +
    40 };
    │ │ │ │ +
    │ │ │ │ +
    41
    │ │ │ │ +
    42 template<typename SourceNode, typename Transformation, template<typename,typename...> class TransformedNode>
    │ │ │ │ +
    │ │ │ │ +
    43 struct GenericCompositeNodeTransformationTemplate
    │ │ │ │ +
    44 {
    │ │ │ │ +
    45 template<typename... TC>
    │ │ │ │ +
    │ │ │ │ +
    46 struct result
    │ │ │ │ +
    47 {
    │ │ │ │ +
    48 typedef TransformedNode<SourceNode,TC...> type;
    │ │ │ │ +
    49 };
    │ │ │ │ +
    │ │ │ │ +
    50 };
    │ │ │ │ +
    │ │ │ │ +
    51
    │ │ │ │ +
    53
    │ │ │ │ +
    54 } // namespace TypeTree
    │ │ │ │ +
    55} //namespace Dune
    │ │ │ │ +
    56
    │ │ │ │ +
    57#endif // DUNE_TYPETREE_POWERCOMPOSITENODETRANSFORMATIONTEMPLATES_HH
    │ │ │ │ + │ │ │ │
    Dune
    Definition accumulate_static.hh:16
    │ │ │ │ -
    Dune::TypeTree::Exception
    Base class for all TypeTree exceptions.
    Definition exceptions.hh:21
    │ │ │ │ +
    Dune::TypeTree::GenericPowerNodeTransformationTemplate
    Definition powercompositenodetransformationtemplates.hh:23
    │ │ │ │ +
    Dune::TypeTree::GenericPowerNodeTransformationTemplate::result
    Definition powercompositenodetransformationtemplates.hh:26
    │ │ │ │ +
    Dune::TypeTree::GenericPowerNodeTransformationTemplate::result::type
    TransformedNode< SourceNode, TC, StaticDegree< SourceNode >::value > type
    Definition powercompositenodetransformationtemplates.hh:27
    │ │ │ │ +
    Dune::TypeTree::GenericDynamicPowerNodeTransformationTemplate
    Definition powercompositenodetransformationtemplates.hh:34
    │ │ │ │ +
    Dune::TypeTree::GenericDynamicPowerNodeTransformationTemplate::result
    Definition powercompositenodetransformationtemplates.hh:37
    │ │ │ │ +
    Dune::TypeTree::GenericDynamicPowerNodeTransformationTemplate::result::type
    TransformedNode< SourceNode, TC > type
    Definition powercompositenodetransformationtemplates.hh:38
    │ │ │ │ +
    Dune::TypeTree::GenericCompositeNodeTransformationTemplate
    Definition powercompositenodetransformationtemplates.hh:44
    │ │ │ │ +
    Dune::TypeTree::GenericCompositeNodeTransformationTemplate::result
    Definition powercompositenodetransformationtemplates.hh:47
    │ │ │ │ +
    Dune::TypeTree::GenericCompositeNodeTransformationTemplate::result::type
    TransformedNode< SourceNode, TC... > type
    Definition powercompositenodetransformationtemplates.hh:48
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,37 +1,90 @@ │ │ │ │ │ dune-typetree 2.10 │ │ │ │ │ Loading... │ │ │ │ │ Searching... │ │ │ │ │ No Matches │ │ │ │ │ * _d_u_n_e │ │ │ │ │ * _t_y_p_e_t_r_e_e │ │ │ │ │ -exceptions.hh │ │ │ │ │ +powercompositenodetransformationtemplates.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#ifndef DUNE_TYPETREE_EXCEPTIONS_HH │ │ │ │ │ -6#define DUNE_TYPETREE_EXCEPTIONS_HH │ │ │ │ │ -7 │ │ │ │ │ -8#include │ │ │ │ │ -9 │ │ │ │ │ -15namespace _D_u_n_e { │ │ │ │ │ -16 namespace TypeTree { │ │ │ │ │ -17 │ │ │ │ │ -_1_9 class _E_x_c_e_p_t_i_o_n │ │ │ │ │ -20 : public Dune::Exception │ │ │ │ │ -21 {}; │ │ │ │ │ -22 │ │ │ │ │ -23 } // namespace TypeTree │ │ │ │ │ -24} // namespace Dune │ │ │ │ │ -25 │ │ │ │ │ -26#endif // DUNE_TYPETREE_EXCEPTIONS_HH │ │ │ │ │ +5 │ │ │ │ │ +6#ifndef DUNE_TYPETREE_POWERCOMPOSITENODETRANSFORMATIONTEMPLATES_HH │ │ │ │ │ +7#define DUNE_TYPETREE_POWERCOMPOSITENODETRANSFORMATIONTEMPLATES_HH │ │ │ │ │ +8 │ │ │ │ │ +9#include │ │ │ │ │ +10 │ │ │ │ │ +11#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> │ │ │ │ │ +12 │ │ │ │ │ +13namespace _D_u_n_e { │ │ │ │ │ +14 namespace TypeTree { │ │ │ │ │ +15 │ │ │ │ │ +21 template class TransformedNode> │ │ │ │ │ +_2_2 struct _G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e │ │ │ │ │ +23 { │ │ │ │ │ +24 template │ │ │ │ │ +_2_5 struct _r_e_s_u_l_t │ │ │ │ │ +26 { │ │ │ │ │ +_2_7 typedef TransformedNode::value> _t_y_p_e; │ │ │ │ │ +28 }; │ │ │ │ │ +29 }; │ │ │ │ │ +30 │ │ │ │ │ +31 │ │ │ │ │ +32 template class TransformedNode> │ │ │ │ │ +_3_3 struct _G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e │ │ │ │ │ +34 { │ │ │ │ │ +35 template │ │ │ │ │ +_3_6 struct _r_e_s_u_l_t │ │ │ │ │ +37 { │ │ │ │ │ +_3_8 typedef TransformedNode _t_y_p_e; │ │ │ │ │ +39 }; │ │ │ │ │ +40 }; │ │ │ │ │ +41 │ │ │ │ │ +42 template class TransformedNode> │ │ │ │ │ +_4_3 struct _G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e │ │ │ │ │ +44 { │ │ │ │ │ +45 template │ │ │ │ │ +_4_6 struct _r_e_s_u_l_t │ │ │ │ │ +47 { │ │ │ │ │ +_4_8 typedef TransformedNode _t_y_p_e; │ │ │ │ │ +49 }; │ │ │ │ │ +50 }; │ │ │ │ │ +51 │ │ │ │ │ +53 │ │ │ │ │ +54 } // namespace TypeTree │ │ │ │ │ +55} //namespace Dune │ │ │ │ │ +56 │ │ │ │ │ +57#endif // DUNE_TYPETREE_POWERCOMPOSITENODETRANSFORMATIONTEMPLATES_HH │ │ │ │ │ +_n_o_d_e_i_n_t_e_r_f_a_c_e_._h_h │ │ │ │ │ _D_u_n_e │ │ │ │ │ DDeeffiinniittiioonn accumulate_static.hh:16 │ │ │ │ │ -_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_E_x_c_e_p_t_i_o_n │ │ │ │ │ -Base class for all TypeTree exceptions. │ │ │ │ │ -DDeeffiinniittiioonn exceptions.hh:21 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e │ │ │ │ │ +DDeeffiinniittiioonn powercompositenodetransformationtemplates.hh:23 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_:_:_r_e_s_u_l_t │ │ │ │ │ +DDeeffiinniittiioonn powercompositenodetransformationtemplates.hh:26 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_:_:_r_e_s_u_l_t_:_:_t_y_p_e │ │ │ │ │ +TransformedNode< SourceNode, TC, StaticDegree< SourceNode >::value > type │ │ │ │ │ +DDeeffiinniittiioonn powercompositenodetransformationtemplates.hh:27 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e │ │ │ │ │ +DDeeffiinniittiioonn powercompositenodetransformationtemplates.hh:34 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_:_:_r_e_s_u_l_t │ │ │ │ │ +DDeeffiinniittiioonn powercompositenodetransformationtemplates.hh:37 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_D_y_n_a_m_i_c_P_o_w_e_r_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_:_:_r_e_s_u_l_t_:_:_t_y_p_e │ │ │ │ │ +TransformedNode< SourceNode, TC > type │ │ │ │ │ +DDeeffiinniittiioonn powercompositenodetransformationtemplates.hh:38 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e │ │ │ │ │ +DDeeffiinniittiioonn powercompositenodetransformationtemplates.hh:44 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_:_:_r_e_s_u_l_t │ │ │ │ │ +DDeeffiinniittiioonn powercompositenodetransformationtemplates.hh:47 │ │ │ │ │ +_D_u_n_e_:_:_T_y_p_e_T_r_e_e_:_:_G_e_n_e_r_i_c_C_o_m_p_o_s_i_t_e_N_o_d_e_T_r_a_n_s_f_o_r_m_a_t_i_o_n_T_e_m_p_l_a_t_e_:_:_r_e_s_u_l_t_:_:_t_y_p_e │ │ │ │ │ +TransformedNode< SourceNode, TC... > type │ │ │ │ │ +DDeeffiinniittiioonn powercompositenodetransformationtemplates.hh:48 │ │ │ │ │ =============================================================================== │ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8 │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00090.html │ │ │ │ @@ -214,16 +214,16 @@ │ │ │ │ ) │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Apply visitor to TypeTree.

    │ │ │ │ -
    #include <dune/typetree/traversal.hh>
    │ │ │ │ - │ │ │ │ +
    #include <dune/typetree/traversal.hh>
    │ │ │ │ + │ │ │ │

    This function applies the given visitor to the given tree. Both visitor and tree may be const or non-const (if the compiler supports rvalue references, they may even be a non-const temporary).

    │ │ │ │
    Note
    The visitor must implement the interface laid out by DefaultVisitor (most easily achieved by inheriting from it) and specify the required type of tree traversal (static or dynamic) by inheriting from either StaticTraversal or DynamicTraversal.
    │ │ │ │
    Parameters
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    treeThe tree the visitor will be applied to.
    visitorThe visitor to apply to the tree.
    │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00924.html │ │ │ │ @@ -78,26 +78,26 @@ │ │ │ │
    Dune::TypeTree::or_< result_type > Struct Template Reference
    dune-typetree » Traversal
    │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │

    Statically combine two values of type result_type using ||. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ +

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  reduce
     
    │ │ │ │

    Detailed Description

    │ │ │ │
    template<typename result_type>
    │ │ │ │ struct Dune::TypeTree::or_< result_type >

    Statically combine two values of type result_type using ||.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00928.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Static Public Attributes | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::or_< result_type >::reduce< r1, r2 > Struct Template Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ +

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Static Public Attributes

    static const result_type result = r1 || r2
     
    │ │ │ │

    Member Data Documentation

    │ │ │ │ @@ -111,15 +111,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00932.html │ │ │ │ @@ -78,26 +78,26 @@ │ │ │ │
    Dune::TypeTree::and_< result_type > Struct Template Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Statically combine two values of type result_type using &&. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ +

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  reduce
     
    │ │ │ │

    Detailed Description

    │ │ │ │
    template<typename result_type>
    │ │ │ │ struct Dune::TypeTree::and_< result_type >

    Statically combine two values of type result_type using &&.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00936.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Static Public Attributes | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::and_< result_type >::reduce< r1, r2 > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ +

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Static Public Attributes

    static const result_type result = r1 && r2
     
    │ │ │ │

    Member Data Documentation

    │ │ │ │ @@ -111,15 +111,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00940.html │ │ │ │ @@ -78,26 +78,26 @@ │ │ │ │
    Dune::TypeTree::plus< result_type > Struct Template Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Statically combine two values of type result_type using +. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ +

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  reduce
     
    │ │ │ │

    Detailed Description

    │ │ │ │
    template<typename result_type>
    │ │ │ │ struct Dune::TypeTree::plus< result_type >

    Statically combine two values of type result_type using +.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00944.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Static Public Attributes | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::plus< result_type >::reduce< r1, r2 > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ +

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Static Public Attributes

    static const result_type result = r1 + r2
     
    │ │ │ │

    Member Data Documentation

    │ │ │ │ @@ -111,15 +111,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00948.html │ │ │ │ @@ -78,26 +78,26 @@ │ │ │ │
    Dune::TypeTree::minus< result_type > Struct Template Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Statically combine two values of type result_type using -. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ +

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  reduce
     
    │ │ │ │

    Detailed Description

    │ │ │ │
    template<typename result_type>
    │ │ │ │ struct Dune::TypeTree::minus< result_type >

    Statically combine two values of type result_type using -.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00952.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Static Public Attributes | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::minus< result_type >::reduce< r1, r2 > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ +

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Static Public Attributes

    static const result_type result = r1 - r2
     
    │ │ │ │

    Member Data Documentation

    │ │ │ │ @@ -111,15 +111,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00956.html │ │ │ │ @@ -78,26 +78,26 @@ │ │ │ │
    Dune::TypeTree::multiply< result_type > Struct Template Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Statically combine two values of type result_type using *. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ +

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  reduce
     
    │ │ │ │

    Detailed Description

    │ │ │ │
    template<typename result_type>
    │ │ │ │ struct Dune::TypeTree::multiply< result_type >

    Statically combine two values of type result_type using *.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00960.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Static Public Attributes | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::multiply< result_type >::reduce< r1, r2 > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ +

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Static Public Attributes

    static const result_type result = r1 * r2
     
    │ │ │ │

    Member Data Documentation

    │ │ │ │ @@ -111,15 +111,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00964.html │ │ │ │ @@ -78,26 +78,26 @@ │ │ │ │
    Dune::TypeTree::min< result_type > Struct Template Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Statically combine two values of type result_type by returning their minimum. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ +

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  reduce
     
    │ │ │ │

    Detailed Description

    │ │ │ │
    template<typename result_type>
    │ │ │ │ struct Dune::TypeTree::min< result_type >

    Statically combine two values of type result_type by returning their minimum.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00968.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Static Public Attributes | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::min< result_type >::reduce< r1, r2 > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ +

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Static Public Attributes

    static const result_type result = r1 < r2 ? r1 : r2
     
    │ │ │ │

    Member Data Documentation

    │ │ │ │ @@ -111,15 +111,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00972.html │ │ │ │ @@ -78,26 +78,26 @@ │ │ │ │
    Dune::TypeTree::max< result_type > Struct Template Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Statically combine two values of type result_type by returning their maximum. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ +

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  reduce
     
    │ │ │ │

    Detailed Description

    │ │ │ │
    template<typename result_type>
    │ │ │ │ struct Dune::TypeTree::max< result_type >

    Statically combine two values of type result_type by returning their maximum.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a00976.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Static Public Attributes | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::max< result_type >::reduce< r1, r2 > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ +

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Static Public Attributes

    static const result_type result = r1 > r2 ? r1 : r2
     
    │ │ │ │

    Member Data Documentation

    │ │ │ │ @@ -111,15 +111,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01016.html │ │ │ │ @@ -80,15 +80,15 @@ │ │ │ │
    Dune::TypeTree::AccumulateValue< Tree, Functor, Reduction, startValue, ParentChildReduction > Struct Template Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Statically accumulate a value over the nodes of a TypeTree. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ +

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef Functor::result_type result_type
     The result type of the computation.
     
    │ │ │ │ @@ -124,19 +124,19 @@ │ │ │ │
    static const bool value = true;
    │ │ │ │
    };
    │ │ │ │
    │ │ │ │
    // Calculate the per-node result.
    │ │ │ │
    template<typename Node, typename TreePath>
    │ │ │ │
    struct visit
    │ │ │ │
    {
    │ │ │ │ -
    static const result_type result = ...;
    │ │ │ │ +
    static const result_type result = ...;
    │ │ │ │
    };
    │ │ │ │
    │ │ │ │
    };
    │ │ │ │ -
    result
    static const result_type result
    Definition accumulate_static.hh:113
    │ │ │ │ +
    result
    static const result_type result
    Definition accumulate_static.hh:113
    │ │ │ │
    Dune::TypeTree::AccumulateValue::result_type
    Functor::result_type result_type
    The result type of the computation.
    Definition accumulate_static.hh:265
    │ │ │ │
    Template Parameters
    │ │ │ │
    │ │ │ │ │ │ │ │
    ReductionThe reduction operator used to accumulate the per-node results.
    │ │ │ │ │ │ │ │ │ │ │ │ @@ -145,15 +145,15 @@ │ │ │ │
    struct ReductionOperator
    │ │ │ │
    {
    │ │ │ │
    │ │ │ │
    // combine two per-node results
    │ │ │ │
    template<result_type r1, result_type r2>
    │ │ │ │
    struct reduce
    │ │ │ │
    {
    │ │ │ │ -
    static const result_type result = ...;
    │ │ │ │ +
    static const result_type result = ...;
    │ │ │ │
    };
    │ │ │ │
    │ │ │ │
    };
    │ │ │ │
    Template Parameters
    │ │ │ │ │ │ │ │ │ │ │ │
    startValueThe starting value fed into the initial accumulation step.
    │ │ │ │ @@ -202,15 +202,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    The accumulated result of the computation.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01068.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Types | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::TypeAccumulationPolicy< Functor, Reduction, StartType, ParentChildReduction, ReductionAlgorithm > Struct Template Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ +

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -220,15 +220,15 @@ │ │ │ │

    │ │ │ │ Public Types

    typedef Functor functor
     
    typedef Reduction sibling_reduction
     
    │ │ │ │
    │ │ │ │

    The initial result type. This type will be feed as first operand to the reduction operators when doing the first accumulation (and there is no calculated result to accumulate with yet).

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01072.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::AccumulateType< Tree, Policy > Struct Template Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Statically accumulate a type over the nodes of a TypeTree. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ +

    #include <dune/typetree/accumulate_static.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef accumulate_type< Tree, Policy, typenamePolicy::start_type, HybridTreePath<>, NodeTag< Tree > >::type type
     The accumulated result of the computation.
     
    │ │ │ │ @@ -118,15 +118,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    The accumulated result of the computation.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01076.html │ │ │ │ @@ -82,15 +82,15 @@ │ │ │ │
    Dune::TypeTree::CompositeNode< Children > Class Template Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Base class for composite nodes based on variadic templates. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/compositenode.hh>

    │ │ │ │ +

    #include <dune/typetree/compositenode.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  Child
     Access to the type and storage type of the i-th child. More...
     
    │ │ │ │ @@ -819,15 +819,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Mark this class as a non power in the dune-typetree.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this class was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01080.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::CompositeNode< Children >::Child< k > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Access to the type and storage type of the i-th child. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/compositenode.hh>

    │ │ │ │ +

    #include <dune/typetree/compositenode.hh>

    │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -136,15 +136,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    The type of the child.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01084.html │ │ │ │ @@ -81,15 +81,15 @@ │ │ │ │
    Dune::TypeTree::DynamicPowerNode< T > Class Template Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Collect multiple instances of type T within a dune-typetree. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/dynamicpowernode.hh>

    │ │ │ │ +

    #include <dune/typetree/dynamicpowernode.hh>

    │ │ │ │

    │ │ │ │ Public Types

    typedef std::tuple_element< k, ChildTypes >::type Type
     The type of the child.
     
    typedef std::tuple_element< k, ChildTypes >::type type
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -776,15 +776,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Mark this class as a power in the dune-typetree.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this class was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01088.html │ │ │ │ @@ -76,29 +76,29 @@ │ │ │ │
    Dune::TypeTree::Exception Class Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Base class for all TypeTree exceptions. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/exceptions.hh>

    │ │ │ │ +

    #include <dune/typetree/exceptions.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::Exception:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │

    Detailed Description

    │ │ │ │

    Base class for all TypeTree exceptions.

    │ │ │ │
    The documentation for this class was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01092.html │ │ │ │ @@ -82,15 +82,15 @@ │ │ │ │
    Dune::TypeTree::FilteredCompositeNode< Node, Filter > Class Template Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Base class for composite nodes representing a filtered view on an underlying composite node. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/filteredcompositenode.hh>

    │ │ │ │ +

    #include <dune/typetree/filteredcompositenode.hh>

    │ │ │ │

    │ │ │ │ Public Types

    typedef DynamicPowerNodeTag NodeTag
     The type tag that describes the node.
     
    typedef T ChildType
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  Child
     Access to the type and storage type of the i-th child. More...
     
    │ │ │ │ @@ -693,15 +693,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Mark this class as a non power in the dune-typetree.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this class was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01100.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::FilteredCompositeNode< Node, Filter >::Child< k > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Access to the type and storage type of the i-th child. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/filteredcompositenode.hh>

    │ │ │ │ +

    #include <dune/typetree/filteredcompositenode.hh>

    │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -136,15 +136,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    The type of the child.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01104.html │ │ │ │ @@ -76,20 +76,20 @@ │ │ │ │
    Dune::TypeTree::FilterEntry< new_k, old_k > Struct Template Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    A filter entry describing the mapping of one child in the filtered node. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/filters.hh>

    │ │ │ │ +

    #include <dune/typetree/filters.hh>

    │ │ │ │

    Detailed Description

    │ │ │ │
    template<std::size_t new_k, std::size_t old_k>
    │ │ │ │ struct Dune::TypeTree::FilterEntry< new_k, old_k >

    A filter entry describing the mapping of one child in the filtered node.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01108.html │ │ │ │ @@ -81,15 +81,15 @@ │ │ │ │
    Dune::TypeTree::FilterResult< FilterEntries > Struct Template Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    The result of a filter. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/filters.hh>

    │ │ │ │ +

    #include <dune/typetree/filters.hh>

    │ │ │ │

    │ │ │ │ Public Types

    typedef OriginalChild::Type Type
     The type of the child.
     
    typedef OriginalChild::type type
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  apply
     
    │ │ │ │ │ │ │ │

    │ │ │ │ @@ -144,15 +144,15 @@ │ │ │ │

    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01112.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Types | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::FilterResult< FilterEntries >::apply< Node > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/filters.hh>

    │ │ │ │ +

    #include <dune/typetree/filters.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -143,15 +143,15 @@ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef std::tuple< typename Node::template Child< FilterEntries::original_index >... > Children
     
    typedef std::tuple< typename Node::template Child< FilterEntries::original_index >::Type... > ChildTypes
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01116.html │ │ │ │ @@ -76,19 +76,19 @@ │ │ │ │
    Dune::TypeTree::SimpleFilterTag Struct Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Tag describing a simple filter that can only decide whether or not to include a single given child. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/filters.hh>

    │ │ │ │ +

    #include <dune/typetree/filters.hh>

    │ │ │ │

    Detailed Description

    │ │ │ │

    Tag describing a simple filter that can only decide whether or not to include a single given child.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01120.html │ │ │ │ @@ -76,19 +76,19 @@ │ │ │ │
    Dune::TypeTree::AdvancedFilterTag Struct Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Tag describing an advanced filter that has full control over the construction of the list of FilterEntries. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/filters.hh>

    │ │ │ │ +

    #include <dune/typetree/filters.hh>

    │ │ │ │

    Detailed Description

    │ │ │ │

    Tag describing an advanced filter that has full control over the construction of the list of FilterEntries.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01124.html │ │ │ │ @@ -80,15 +80,15 @@ │ │ │ │
    Dune::TypeTree::AdvancedFilter Struct Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Base class for advanced filters. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/filters.hh>

    │ │ │ │ +

    #include <dune/typetree/filters.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::AdvancedFilter:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -124,15 +124,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Filter tag for deciding on filter application mechanism.

    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01128.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::AdvancedFilter::apply< Node, Children > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Apply this filter to the given node and children. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/filters.hh>

    │ │ │ │ +

    #include <dune/typetree/filters.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef implementation defined type
     The result of the filtering process.
     
    │ │ │ │ @@ -111,15 +111,15 @@ │ │ │ │ │ │ │ │

    The result of the filtering process.

    │ │ │ │

    This type must be a model of FilterResult.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01132.html │ │ │ │ @@ -80,15 +80,15 @@ │ │ │ │
    Dune::TypeTree::SimpleFilter Struct Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Default simple filter that accepts any node and leaves its child structure unchanged. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/filters.hh>

    │ │ │ │ +

    #include <dune/typetree/filters.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -118,15 +118,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Filter tag for deciding on filter application mechanism.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01136.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::SimpleFilter::validate< Node > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Validates the combination of filter and node. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/filters.hh>

    │ │ │ │ +

    #include <dune/typetree/filters.hh>

    │ │ │ │

    │ │ │ │ Classes

    struct  apply
     Applies the filter to the given child node. More...
     
    struct  validate
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Static Public Attributes

    static const bool value = true
     True if the combination of filter and node is valid.
     
    │ │ │ │ @@ -118,15 +118,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    True if the combination of filter and node is valid.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01140.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::SimpleFilter::apply< Child, new_index, old_index > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Applies the filter to the given child node. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/filters.hh>

    │ │ │ │ +

    #include <dune/typetree/filters.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Static Public Attributes

    static const bool value = true
     True if the child will be included in the filtered node.
     
    │ │ │ │ @@ -127,15 +127,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    True if the child will be included in the filtered node.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01160.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::IndexFilter< indices > Struct Template Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Filter class for FilteredCompositeNode that selects the children with the given indices. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/filters.hh>

    │ │ │ │ +

    #include <dune/typetree/filters.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::IndexFilter< indices >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -126,15 +126,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Filter tag for deciding on filter application mechanism.

    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01180.html │ │ │ │ @@ -78,27 +78,27 @@ │ │ │ │
    Dune::TypeTree::filter< Filter > Struct Template Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Adapter class that takes a SimpleFilter, validated it and turns it into an AdvancedFilter. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/filters.hh>

    │ │ │ │ +

    #include <dune/typetree/filters.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  apply
     Apply the filter. More...
     
    │ │ │ │

    Detailed Description

    │ │ │ │
    template<typename Filter>
    │ │ │ │ struct Dune::TypeTree::filter< Filter >

    Adapter class that takes a SimpleFilter, validated it and turns it into an AdvancedFilter.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01184.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::filter< Filter >::apply< Node, Children > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Apply the filter. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/filters.hh>

    │ │ │ │ +

    #include <dune/typetree/filters.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef filter_helper< Filter, 0, 0, Children... >::template apply ::type type
     
    │ │ │ │

    Detailed Description

    │ │ │ │ @@ -110,15 +110,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01188.html │ │ │ │ @@ -77,15 +77,15 @@ │ │ │ │ Classes | │ │ │ │ Public Member Functions | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::FixedCapacityStackView< T > Class Template Reference
    dune-typetree » TreePath
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/fixedcapacitystack.hh>

    │ │ │ │ +

    #include <dune/typetree/fixedcapacitystack.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::FixedCapacityStackView< T >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -481,15 +481,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this class was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01196.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Member Functions | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::FixedCapacityStack< T, capacity > Class Template Reference
    dune-typetree » TreePath
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/fixedcapacitystack.hh>

    │ │ │ │ +

    #include <dune/typetree/fixedcapacitystack.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::FixedCapacityStack< T, capacity >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -478,15 +478,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this class was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01200.html │ │ │ │ @@ -78,15 +78,15 @@ │ │ │ │ Static Public Member Functions | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::GenericLeafNodeTransformation< SourceNode, Transformation, TransformedNode > Struct Template Reference
    dune-typetree » Transformation
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │ +

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -275,15 +275,15 @@ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef TransformedNode transformed_type
     
    typedef std::shared_ptr< transformed_type > transformed_storage_type
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01204.html │ │ │ │ @@ -78,15 +78,15 @@ │ │ │ │ Static Public Member Functions | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate > Struct Template Reference
    dune-typetree » Transformation
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │ +

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::TemplatizedGenericPowerNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -279,15 +279,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01208.html │ │ │ │ @@ -77,15 +77,15 @@ │ │ │ │ Public Types | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::TemplatizedGenericPowerNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate >::result< TC > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │ +

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -156,15 +156,15 @@ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef TransformedNodeTemplate< TC >::type type
     
    typedef std::shared_ptr< type > storage_type
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01212.html │ │ │ │ @@ -77,15 +77,15 @@ │ │ │ │ Static Public Member Functions | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::GenericPowerNodeTransformation< SourceNode, Transformation, TransformedNode > Struct Template Reference
    dune-typetree » Transformation
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │ +

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::GenericPowerNodeTransformation< SourceNode, Transformation, TransformedNode >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -93,19 +93,19 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Static Public Member Functions

    static result< TC >::type transform (const SourceNode &s, const Transformation &t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children)
    static result< TC >::type transform (const SourceNode &s, const Transformation &t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children)
     
    static result< TC >::type transform (std::shared_ptr< const SourceNode > s, const Transformation &t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children)
    static result< TC >::type transform (std::shared_ptr< const SourceNode > s, const Transformation &t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children)
     
    static result< TC >::storage_type transform_storage (std::shared_ptr< const SourceNode > s, const Transformation &t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children)
    static result< TC >::storage_type transform_storage (std::shared_ptr< const SourceNode > s, const Transformation &t, const std::array< std::shared_ptr< TC >, result< TC >::degree > &children)
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Static Public Attributes

    static const bool recursive
     
    │ │ │ │ @@ -116,29 +116,29 @@ │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -158,29 +158,29 @@ │ │ │ │
    │ │ │ │
    │ │ │ │
    static result< TC >::type Dune::TypeTree::TemplatizedGenericPowerNodeTransformation< SourceNode, Transformation, GenericPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::transform static result< TC >::type Dune::TypeTree::TemplatizedGenericPowerNodeTransformation< SourceNode, Transformation, GenericPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::transform (const SourceNode & s,
    const Transformation & t,
    const std::array< std::shared_ptr< TC >, result< TC >::degree > & const std::array< std::shared_ptr< TC >, result< TC >::degree > & children 
    )
    │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -200,29 +200,29 @@ │ │ │ │
    │ │ │ │
    │ │ │ │
    static result< TC >::type Dune::TypeTree::TemplatizedGenericPowerNodeTransformation< SourceNode, Transformation, GenericPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::transform static result< TC >::type Dune::TypeTree::TemplatizedGenericPowerNodeTransformation< SourceNode, Transformation, GenericPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::transform (std::shared_ptr< const SourceNode > s,
    const Transformation & t,
    const std::array< std::shared_ptr< TC >, result< TC >::degree > & const std::array< std::shared_ptr< TC >, result< TC >::degree > & children 
    )
    │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -243,28 +243,28 @@ │ │ │ │
    │ │ │ │
    │ │ │ │
    static result< TC >::storage_type Dune::TypeTree::TemplatizedGenericPowerNodeTransformation< SourceNode, Transformation, GenericPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::transform_storage static result< TC >::storage_type Dune::TypeTree::TemplatizedGenericPowerNodeTransformation< SourceNode, Transformation, GenericPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::transform_storage (std::shared_ptr< const SourceNode > s,
    const Transformation & t,
    const std::array< std::shared_ptr< TC >, result< TC >::degree > & const std::array< std::shared_ptr< TC >, result< TC >::degree > & children 
    )
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │
    const bool Dune::TypeTree::TemplatizedGenericPowerNodeTransformation< SourceNode, Transformation, GenericPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::recursiveconst bool Dune::TypeTree::TemplatizedGenericPowerNodeTransformation< SourceNode, Transformation, GenericPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::recursive
    │ │ │ │     		│ │ │ │ staticinherited
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01216.html │ │ │ │ @@ -78,15 +78,15 @@ │ │ │ │ Static Public Member Functions | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate > Struct Template Reference
    dune-typetree » Transformation
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │ +

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -279,15 +279,15 @@ │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01220.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Types | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate >::result< TC > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │ +

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -123,15 +123,15 @@ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef TransformedNodeTemplate< TC >::type type
     
    typedef std::shared_ptr< type > storage_type
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01224.html │ │ │ │ @@ -77,15 +77,15 @@ │ │ │ │ Static Public Member Functions | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::GenericDynamicPowerNodeTransformation< SourceNode, Transformation, TransformedNode > Struct Template Reference
    dune-typetree » Transformation
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │ +

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::GenericDynamicPowerNodeTransformation< SourceNode, Transformation, TransformedNode >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -93,19 +93,19 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Static Public Member Functions

    static result< TC >::type transform (const SourceNode &s, const Transformation &t, const std::vector< std::shared_ptr< TC > > &children)
    static result< TC >::type transform (const SourceNode &s, const Transformation &t, const std::vector< std::shared_ptr< TC > > &children)
     
    static result< TC >::type transform (std::shared_ptr< const SourceNode > s, const Transformation &t, const std::vector< std::shared_ptr< TC > > &children)
    static result< TC >::type transform (std::shared_ptr< const SourceNode > s, const Transformation &t, const std::vector< std::shared_ptr< TC > > &children)
     
    static result< TC >::storage_type transform_storage (std::shared_ptr< const SourceNode > s, const Transformation &t, const std::vector< std::shared_ptr< TC > > &children)
    static result< TC >::storage_type transform_storage (std::shared_ptr< const SourceNode > s, const Transformation &t, const std::vector< std::shared_ptr< TC > > &children)
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Static Public Attributes

    static const bool recursive
     
    │ │ │ │ @@ -116,15 +116,15 @@ │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -158,15 +158,15 @@ │ │ │ │
    │ │ │ │
    │ │ │ │
    static result< TC >::type Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation< SourceNode, Transformation, GenericDynamicPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::transform static result< TC >::type Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation< SourceNode, Transformation, GenericDynamicPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::transform (const SourceNode & s,
    │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -200,15 +200,15 @@ │ │ │ │
    │ │ │ │
    │ │ │ │
    static result< TC >::type Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation< SourceNode, Transformation, GenericDynamicPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::transform static result< TC >::type Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation< SourceNode, Transformation, GenericDynamicPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::transform (std::shared_ptr< const SourceNode > s,
    │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -243,28 +243,28 @@ │ │ │ │
    │ │ │ │
    │ │ │ │
    static result< TC >::storage_type Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation< SourceNode, Transformation, GenericDynamicPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::transform_storage static result< TC >::storage_type Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation< SourceNode, Transformation, GenericDynamicPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::transform_storage (std::shared_ptr< const SourceNode > s,
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │
    const bool Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation< SourceNode, Transformation, GenericDynamicPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::recursiveconst bool Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation< SourceNode, Transformation, GenericDynamicPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::recursive
    │ │ │ │     		│ │ │ │ staticinherited
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01228.html │ │ │ │ @@ -78,15 +78,15 @@ │ │ │ │ Static Public Member Functions | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate > Struct Template Reference
    dune-typetree » Transformation
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │ +

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -279,15 +279,15 @@ │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01232.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Types | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation< SourceNode, Transformation, TransformedNodeTemplate >::result< TC > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │ +

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -123,15 +123,15 @@ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef TransformedNodeTemplate< TC... >::type type
     
    typedef std::shared_ptr< type > storage_type
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01236.html │ │ │ │ @@ -77,15 +77,15 @@ │ │ │ │ Static Public Member Functions | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::GenericCompositeNodeTransformation< SourceNode, Transformation, TransformedNode > Struct Template Reference
    dune-typetree » Transformation
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │ +

    #include <dune/typetree/generictransformationdescriptors.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::GenericCompositeNodeTransformation< SourceNode, Transformation, TransformedNode >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -93,19 +93,19 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Static Public Member Functions

    static result< TC... >::type transform (const SourceNode &s, const Transformation &t, std::shared_ptr< TC >... children)
    static result< TC... >::type transform (const SourceNode &s, const Transformation &t, std::shared_ptr< TC >... children)
     
    static result< TC... >::type transform (std::shared_ptr< const SourceNode > s, const Transformation &t, std::shared_ptr< TC >... children)
    static result< TC... >::type transform (std::shared_ptr< const SourceNode > s, const Transformation &t, std::shared_ptr< TC >... children)
     
    static result< TC... >::storage_type transform_storage (std::shared_ptr< const SourceNode > s, const Transformation &t, std::shared_ptr< TC >... children)
    static result< TC... >::storage_type transform_storage (std::shared_ptr< const SourceNode > s, const Transformation &t, std::shared_ptr< TC >... children)
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Static Public Attributes

    static const bool recursive
     
    │ │ │ │ @@ -116,15 +116,15 @@ │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -158,15 +158,15 @@ │ │ │ │
    │ │ │ │
    │ │ │ │
    static result< TC... >::type Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation< SourceNode, Transformation, GenericCompositeNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::transform static result< TC... >::type Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation< SourceNode, Transformation, GenericCompositeNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::transform (const SourceNode & s,
    │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -200,15 +200,15 @@ │ │ │ │
    │ │ │ │
    │ │ │ │
    static result< TC... >::type Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation< SourceNode, Transformation, GenericCompositeNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::transform static result< TC... >::type Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation< SourceNode, Transformation, GenericCompositeNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::transform (std::shared_ptr< const SourceNode > s,
    │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -243,28 +243,28 @@ │ │ │ │
    │ │ │ │
    │ │ │ │
    static result< TC... >::storage_type Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation< SourceNode, Transformation, GenericCompositeNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::transform_storage static result< TC... >::storage_type Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation< SourceNode, Transformation, GenericCompositeNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::transform_storage (std::shared_ptr< const SourceNode > s,
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │
    const bool Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation< SourceNode, Transformation, GenericCompositeNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::recursiveconst bool Dune::TypeTree::TemplatizedGenericCompositeNodeTransformation< SourceNode, Transformation, GenericCompositeNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::template result >::recursive
    │ │ │ │     		│ │ │ │ staticinherited
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01240.html │ │ │ │ @@ -82,15 +82,15 @@ │ │ │ │
    Dune::TypeTree::LeafNode Class Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Base class for leaf nodes in a dune-typetree. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/leafnode.hh>

    │ │ │ │ +

    #include <dune/typetree/leafnode.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef LeafNodeTag NodeTag
     The type tag that describes a LeafNode.
     
    │ │ │ │ @@ -262,15 +262,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Mark this class as a non power in the dune-typetree.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this class was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01244.html │ │ │ │ @@ -81,15 +81,15 @@ │ │ │ │
    Dune::TypeTree::NodeInterface Struct Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Interface for nodes in a dune-typetree. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/nodeinterface.hh>

    │ │ │ │ +

    #include <dune/typetree/nodeinterface.hh>

    │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -255,15 +255,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Whether this is a power node in the dune-typetree.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01248.html │ │ │ │ @@ -76,19 +76,19 @@ │ │ │ │
    Dune::TypeTree::LeafNodeTag Struct Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Tag designating a leaf node. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/nodetags.hh>

    │ │ │ │ +

    #include <dune/typetree/nodetags.hh>

    │ │ │ │

    Detailed Description

    │ │ │ │

    Tag designating a leaf node.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01252.html │ │ │ │ @@ -76,19 +76,19 @@ │ │ │ │
    Dune::TypeTree::PowerNodeTag Struct Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Tag designating a power node. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/nodetags.hh>

    │ │ │ │ +

    #include <dune/typetree/nodetags.hh>

    │ │ │ │

    Detailed Description

    │ │ │ │

    Tag designating a power node.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01256.html │ │ │ │ @@ -76,19 +76,19 @@ │ │ │ │
    Dune::TypeTree::DynamicPowerNodeTag Struct Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Tag designating a power node with runtime degree. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/nodetags.hh>

    │ │ │ │ +

    #include <dune/typetree/nodetags.hh>

    │ │ │ │

    Detailed Description

    │ │ │ │

    Tag designating a power node with runtime degree.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01260.html │ │ │ │ @@ -76,19 +76,19 @@ │ │ │ │
    Dune::TypeTree::CompositeNodeTag Struct Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Tag designating a composite node. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/nodetags.hh>

    │ │ │ │ +

    #include <dune/typetree/nodetags.hh>

    │ │ │ │

    Detailed Description

    │ │ │ │

    Tag designating a composite node.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01264.html │ │ │ │ @@ -75,23 +75,23 @@ │ │ │ │
    │ │ │ │
    │ │ │ │ Classes
    │ │ │ │
    Dune::TypeTree::GenericPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode > Struct Template Reference
    dune-typetree » Transformation
    │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/powercompositenodetransformationtemplates.hh>

    │ │ │ │ +

    #include <dune/typetree/powercompositenodetransformationtemplates.hh>

    │ │ │ │

    │ │ │ │ Public Types

    typedef ImplementationDefined NodeTag
     The type tag that describes what kind of node this is.
     
    typedef ImplementationDefined NodeStorage
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  result
     
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01268.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Types | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::GenericPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::result< TC > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/powercompositenodetransformationtemplates.hh>

    │ │ │ │ +

    #include <dune/typetree/powercompositenodetransformationtemplates.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef TransformedNode< SourceNode, TC, StaticDegree< SourceNode >::value > type
     
    │ │ │ │

    Member Typedef Documentation

    │ │ │ │ @@ -103,15 +103,15 @@ │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01272.html │ │ │ │ @@ -75,23 +75,23 @@ │ │ │ │
    │ │ │ │
    │ │ │ │ Classes
    │ │ │ │
    Dune::TypeTree::GenericDynamicPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode > Struct Template Reference
    dune-typetree » Transformation
    │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/powercompositenodetransformationtemplates.hh>

    │ │ │ │ +

    #include <dune/typetree/powercompositenodetransformationtemplates.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  result
     
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01276.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Types | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::GenericDynamicPowerNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::result< TC > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/powercompositenodetransformationtemplates.hh>

    │ │ │ │ +

    #include <dune/typetree/powercompositenodetransformationtemplates.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef TransformedNode< SourceNode, TC > type
     
    │ │ │ │

    Member Typedef Documentation

    │ │ │ │ @@ -103,15 +103,15 @@ │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01280.html │ │ │ │ @@ -75,23 +75,23 @@ │ │ │ │
    │ │ │ │
    │ │ │ │ Classes
    │ │ │ │
    Dune::TypeTree::GenericCompositeNodeTransformationTemplate< SourceNode, Transformation, TransformedNode > Struct Template Reference
    dune-typetree » Transformation
    │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/powercompositenodetransformationtemplates.hh>

    │ │ │ │ +

    #include <dune/typetree/powercompositenodetransformationtemplates.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  result
     
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01284.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Types | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::GenericCompositeNodeTransformationTemplate< SourceNode, Transformation, TransformedNode >::result< TC > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/powercompositenodetransformationtemplates.hh>

    │ │ │ │ +

    #include <dune/typetree/powercompositenodetransformationtemplates.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef TransformedNode< SourceNode, TC... > type
     
    │ │ │ │

    Member Typedef Documentation

    │ │ │ │ @@ -103,15 +103,15 @@ │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01288.html │ │ │ │ @@ -82,15 +82,15 @@ │ │ │ │
    Dune::TypeTree::PowerNode< T, k > Class Template Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Collect k instances of type T within a dune-typetree. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/powernode.hh>

    │ │ │ │ +

    #include <dune/typetree/powernode.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  Child
     Access to the type and storage type of the i-th child. More...
     
    │ │ │ │ @@ -1116,15 +1116,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Mark this class as a power in the dune-typetree.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this class was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01292.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::PowerNode< T, k >::Child< i > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Access to the type and storage type of the i-th child. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/powernode.hh>

    │ │ │ │ +

    #include <dune/typetree/powernode.hh>

    │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -136,15 +136,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    The type of the child.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01296.html │ │ │ │ @@ -82,15 +82,15 @@ │ │ │ │
    Dune::TypeTree::ProxyNode< Node > Class Template Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Base class for nodes acting as a proxy for an existing node. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/proxynode.hh>

    │ │ │ │ +

    #include <dune/typetree/proxynode.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::ProxyNode< Node >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -503,15 +503,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Mark this class as a non power in the dune-typetree.

    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this class was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01300.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::StaticChildAccessors< ProxiedNode > Class Template Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Mixin class providing methods for child access with compile-time parameter. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/proxynode.hh>

    │ │ │ │ +

    #include <dune/typetree/proxynode.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::StaticChildAccessors< ProxiedNode >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -340,15 +340,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Sets the i-th child to the passed-in value.

    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this class was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01308.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    Dune::TypeTree::StaticChildAccessors< ProxiedNode >::Child< k > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Access to the type and storage type of the i-th child. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/proxynode.hh>

    │ │ │ │ +

    #include <dune/typetree/proxynode.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::StaticChildAccessors< ProxiedNode >::Child< k >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -92,15 +92,15 @@ │ │ │ │ │ │ │ │
    │ │ │ │

    Detailed Description

    │ │ │ │
    template<typename ProxiedNode>
    │ │ │ │ template<std::size_t k>
    │ │ │ │ struct Dune::TypeTree::StaticChildAccessors< ProxiedNode >::Child< k >

    Access to the type and storage type of the i-th child.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01312.html │ │ │ │ @@ -78,15 +78,15 @@ │ │ │ │
    Dune::TypeTree::DynamicChildAccessors< ProxiedNode > Class Template Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Mixin class providing methods for child access with run-time parameter. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/proxynode.hh>

    │ │ │ │ +

    #include <dune/typetree/proxynode.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::DynamicChildAccessors< ProxiedNode >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -524,15 +524,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Sets the i-th child to the passed-in value.

    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this class was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01316.html │ │ │ │ @@ -91,15 +91,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    Detailed Description

    │ │ │ │
    template<typename Node, typename NodeTag>
    │ │ │ │ struct Dune::TypeTree::ProxyNodeBase< Node, NodeTag >

    Tag-based dispatch to appropriate base class that provides necessary functionality.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01320.html │ │ │ │ @@ -76,20 +76,20 @@ │ │ │ │
    Dune::TypeTree::ProxyNodeBase< Node, LeafNodeTag > Struct Template Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    ProxyNode base class for LeafNode. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/proxynode.hh>

    │ │ │ │ +

    #include <dune/typetree/proxynode.hh>

    │ │ │ │

    Detailed Description

    │ │ │ │
    template<typename Node>
    │ │ │ │ struct Dune::TypeTree::ProxyNodeBase< Node, LeafNodeTag >

    ProxyNode base class for LeafNode.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01324.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::ProxyNodeBase< Node, CompositeNodeTag > Struct Template Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    ProxyNode base class for CompositeNode. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/proxynode.hh>

    │ │ │ │ +

    #include <dune/typetree/proxynode.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::ProxyNodeBase< Node, CompositeNodeTag >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -338,15 +338,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Sets the i-th child to the passed-in value.

    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01328.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::ProxyNodeBase< Node, PowerNodeTag > Struct Template Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    ProxyNode base class for PowerNode. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/proxynode.hh>

    │ │ │ │ +

    #include <dune/typetree/proxynode.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::ProxyNodeBase< Node, PowerNodeTag >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -545,15 +545,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Sets the i-th child to the passed-in value.

    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01332.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::ProxyNodeBase< Node, DynamicPowerNodeTag > Struct Template Reference
    dune-typetree » Nodes
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    ProxyNode base class for DynamicPowerNode. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/proxynode.hh>

    │ │ │ │ +

    #include <dune/typetree/proxynode.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::ProxyNodeBase< Node, DynamicPowerNodeTag >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -545,15 +545,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Sets the i-th child to the passed-in value.

    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01336.html │ │ │ │ @@ -78,15 +78,15 @@ │ │ │ │ Static Public Member Functions | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::SimpleLeafNodeTransformation< SourceNode, Transformation, TransformedNode > Struct Template Reference
    dune-typetree » Transformation
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/simpletransformationdescriptors.hh>

    │ │ │ │ +

    #include <dune/typetree/simpletransformationdescriptors.hh>

    │ │ │ │

    │ │ │ │ Public Types

    typedef T Type
     The type of the child.
     
    typedef T type
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -235,15 +235,15 @@ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef TransformedNode transformed_type
     
    typedef std::shared_ptr< transformed_type > transformed_storage_type
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01340.html │ │ │ │ @@ -78,15 +78,15 @@ │ │ │ │ Static Public Member Functions | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::SimplePowerNodeTransformation< SourceNode, Transformation, TransformedNode > Struct Template Reference
    dune-typetree » Transformation
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/simpletransformationdescriptors.hh>

    │ │ │ │ +

    #include <dune/typetree/simpletransformationdescriptors.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  result
     
    │ │ │ │ │ │ │ │

    │ │ │ │ @@ -218,15 +218,15 @@ │ │ │ │

    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01344.html │ │ │ │ @@ -77,15 +77,15 @@ │ │ │ │ Public Types | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::SimplePowerNodeTransformation< SourceNode, Transformation, TransformedNode >::result< TC > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/simpletransformationdescriptors.hh>

    │ │ │ │ +

    #include <dune/typetree/simpletransformationdescriptors.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -156,15 +156,15 @@ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef TransformedNode< TC, StaticDegree< SourceNode >::value > type
     
    typedef std::shared_ptr< type > storage_type
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01348.html │ │ │ │ @@ -78,15 +78,15 @@ │ │ │ │ Static Public Member Functions | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::SimpleDynamicPowerNodeTransformation< SourceNode, Transformation, TransformedNode > Struct Template Reference
    dune-typetree » Transformation
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/simpletransformationdescriptors.hh>

    │ │ │ │ +

    #include <dune/typetree/simpletransformationdescriptors.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  result
     
    │ │ │ │ │ │ │ │

    │ │ │ │ @@ -218,15 +218,15 @@ │ │ │ │

    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01352.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Types | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::SimpleDynamicPowerNodeTransformation< SourceNode, Transformation, TransformedNode >::result< TC > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/simpletransformationdescriptors.hh>

    │ │ │ │ +

    #include <dune/typetree/simpletransformationdescriptors.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -123,15 +123,15 @@ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef TransformedNode< TC > type
     
    typedef std::shared_ptr< type > storage_type
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01356.html │ │ │ │ @@ -78,15 +78,15 @@ │ │ │ │ Static Public Member Functions | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::SimpleCompositeNodeTransformation< SourceNode, Transformation, TransformedNode > Struct Template Reference
    dune-typetree » Transformation
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/simpletransformationdescriptors.hh>

    │ │ │ │ +

    #include <dune/typetree/simpletransformationdescriptors.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Classes

    struct  result
     
    │ │ │ │ │ │ │ │

    │ │ │ │ @@ -218,15 +218,15 @@ │ │ │ │

    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01360.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Types | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::SimpleCompositeNodeTransformation< SourceNode, Transformation, TransformedNode >::result< TC > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/simpletransformationdescriptors.hh>

    │ │ │ │ +

    #include <dune/typetree/simpletransformationdescriptors.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -123,15 +123,15 @@ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef TransformedNode< TC... > type
     
    typedef std::shared_ptr< type > storage_type
     
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01364.html │ │ │ │ @@ -80,15 +80,15 @@ │ │ │ │
    Dune::TypeTree::TransformTree< SourceTree, Transformation, Tag, recursive > Struct Template Reference
    dune-typetree » Transformation
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Transform a TypeTree. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/transformation.hh>

    │ │ │ │ +

    #include <dune/typetree/transformation.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -397,15 +397,15 @@ │ │ │ │

    │ │ │ │ Public Types

    typedef transformed_type type
     The type of the transformed tree.
     
    typedef type Type
    │ │ │ │
    │ │ │ │

    Apply transformation to storage type of an existing tree, returning a heap-allocated storage type instance of the transformed tree.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01372.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Member Functions | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::Detail::ContainerFactory< LeafToValue > Class Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/treecontainer.hh>

    │ │ │ │ +

    #include <dune/typetree/treecontainer.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -157,15 +157,15 @@ │ │ │ │ │ │ │ │

    │ │ │ │ Public Member Functions

     ContainerFactory (LeafToValue leafToValue)
     Create ContainerFactory.
     
    template<class Node >
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this class was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01376.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Member Functions | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::Detail::TreeContainerVectorBackend< Container > Class Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/treecontainer.hh>

    │ │ │ │ +

    #include <dune/typetree/treecontainer.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -348,15 +348,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Resize the (nested) container depending on the degree of the tree nodes.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this class was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01380.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Member Functions | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::Detail::LeafToDefaultConstructibleValue< LeafToValue > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/treecontainer.hh>

    │ │ │ │ +

    #include <dune/typetree/treecontainer.hh>

    │ │ │ │

    │ │ │ │ Public Member Functions

     TreeContainerVectorBackend (Container &&container)
     Move the passed container into the internal storage.
     
    template<class Tree , TypeTreeConcept< Tree > = true>
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Member Functions

    template<class Node >
    auto operator() (const Node &node) const
     
    │ │ │ │ @@ -116,15 +116,15 @@ │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01392.html │ │ │ │ @@ -81,15 +81,15 @@ │ │ │ │
    Dune::TypeTree::HybridTreePath< T > Class Template Reference
    dune-typetree » TreePath
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    A hybrid version of TreePath that supports both compile time and run time indices. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/treepath.hh>

    │ │ │ │ +

    #include <dune/typetree/treepath.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    using index_sequence = std::index_sequence_for< T... >
     An index_sequence for the entries in this HybridTreePath.
     
    │ │ │ │ @@ -647,15 +647,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Get the size (length) of this path.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this class was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01396.html │ │ │ │ @@ -73,15 +73,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    Dune::TypeTree::TreePathSize< typename > Struct Template Reference
    dune-typetree » TreePath
    │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01400.html │ │ │ │ @@ -73,15 +73,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    Dune::TypeTree::TreePathPushBack< typename, size_t > Struct Template Reference
    dune-typetree » TreePath
    │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01404.html │ │ │ │ @@ -73,15 +73,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    Dune::TypeTree::TreePathPushFront< typename, size_t > Struct Template Reference
    dune-typetree » TreePath
    │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01408.html │ │ │ │ @@ -85,15 +85,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01412.html │ │ │ │ @@ -73,15 +73,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    Dune::TypeTree::TreePathFront< typename > Struct Template Reference
    dune-typetree » TreePath
    │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01416.html │ │ │ │ @@ -85,15 +85,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01420.html │ │ │ │ @@ -73,15 +73,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    Dune::TypeTree::TreePathPopFront< typename > Struct Template Reference
    dune-typetree » TreePath
    │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01424.html │ │ │ │ @@ -73,15 +73,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    Dune::TypeTree::TreePathConcat< typename, typename > Struct Template Reference
    dune-typetree » TreePath
    │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01428.html │ │ │ │ @@ -73,27 +73,27 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    Dune::TypeTree::TreePathSize< HybridTreePath< index_constant< i >... > > Struct Template Reference
    dune-typetree » TreePath
    │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/treepath.hh>

    │ │ │ │ +

    #include <dune/typetree/treepath.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::TreePathSize< HybridTreePath< index_constant< i >... > >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01432.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Types | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::TreePathPushBack< HybridTreePath< index_constant< i >... >, k > Struct Template Reference
    dune-typetree » TreePath
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/treepath.hh>

    │ │ │ │ +

    #include <dune/typetree/treepath.hh>

    │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef HybridTreePath< index_constant< i >..., index_constant< k > > type
     
    │ │ │ │

    Member Typedef Documentation

    │ │ │ │ @@ -101,15 +101,15 @@ │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01436.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Types | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::TreePathPushFront< HybridTreePath< index_constant< i >... >, k > Struct Template Reference
    dune-typetree » TreePath
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/treepath.hh>

    │ │ │ │ +

    #include <dune/typetree/treepath.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef HybridTreePath< index_constant< k >, index_constant< i >... > type
     
    │ │ │ │

    Member Typedef Documentation

    │ │ │ │ @@ -101,15 +101,15 @@ │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01440.html │ │ │ │ @@ -73,27 +73,27 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    Dune::TypeTree::TreePathBack< HybridTreePath< index_constant< k > > > Struct Template Reference
    dune-typetree » TreePath
    │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/treepath.hh>

    │ │ │ │ +

    #include <dune/typetree/treepath.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::TreePathBack< HybridTreePath< index_constant< k > > >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01444.html │ │ │ │ @@ -73,29 +73,29 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    Dune::TypeTree::TreePathBack< HybridTreePath< index_constant< j >, index_constant< k >, index_constant< l >... > > Struct Template Reference
    dune-typetree » TreePath
    │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/treepath.hh>

    │ │ │ │ +

    #include <dune/typetree/treepath.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::TreePathBack< HybridTreePath< index_constant< j >, index_constant< k >, index_constant< l >... > >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01448.html │ │ │ │ @@ -73,27 +73,27 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    Dune::TypeTree::TreePathFront< HybridTreePath< index_constant< k >, index_constant< i >... > > Struct Template Reference
    dune-typetree » TreePath
    │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/treepath.hh>

    │ │ │ │ +

    #include <dune/typetree/treepath.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::TreePathFront< HybridTreePath< index_constant< k >, index_constant< i >... > >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01452.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Types | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::TreePathPopBack< HybridTreePath< index_constant< k > >, i... > Struct Template Reference
    dune-typetree » TreePath
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/treepath.hh>

    │ │ │ │ +

    #include <dune/typetree/treepath.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef HybridTreePath< index_constant< i >... > type
     
    │ │ │ │

    Member Typedef Documentation

    │ │ │ │ @@ -101,15 +101,15 @@ │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01456.html │ │ │ │ @@ -73,29 +73,29 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    Dune::TypeTree::TreePathPopBack< HybridTreePath< index_constant< j >, index_constant< k >, index_constant< l >... >, i... > Struct Template Reference
    dune-typetree » TreePath
    │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/treepath.hh>

    │ │ │ │ +

    #include <dune/typetree/treepath.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::TreePathPopBack< HybridTreePath< index_constant< j >, index_constant< k >, index_constant< l >... >, i... >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01460.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Types | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::TreePathPopFront< HybridTreePath< index_constant< k >, index_constant< i >... > > Struct Template Reference
    dune-typetree » TreePath
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/treepath.hh>

    │ │ │ │ +

    #include <dune/typetree/treepath.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef HybridTreePath< index_constant< i >... > type
     
    │ │ │ │

    Member Typedef Documentation

    │ │ │ │ @@ -101,15 +101,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01464.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Types | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::TreePathConcat< HybridTreePath< index_constant< i >... >, HybridTreePath< index_constant< k >... > > Struct Template Reference
    dune-typetree » TreePath
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/treepath.hh>

    │ │ │ │ +

    #include <dune/typetree/treepath.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef HybridTreePath< index_constant< i >..., index_constant< k >... > type
     
    │ │ │ │

    Member Typedef Documentation

    │ │ │ │ @@ -101,15 +101,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01468.html │ │ │ │ @@ -73,15 +73,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    Dune::first_type< T > Struct Template Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01472.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Types | │ │ │ │ List of all members
    │ │ │ │
    Dune::first_type< T0, T... > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef T0 type
     
    │ │ │ │

    Member Typedef Documentation

    │ │ │ │ @@ -101,15 +101,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01476.html │ │ │ │ @@ -78,15 +78,15 @@ │ │ │ │ Static Public Member Functions | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::has_node_tag< T > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -191,15 +191,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    True if class T defines a NodeTag.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01480.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Attributes | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::has_node_tag< T >::yes Struct Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │

    │ │ │ │ Classes

    struct  no
     
    struct  yes
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Attributes

    char dummy [1]
     
    │ │ │ │

    Member Data Documentation

    │ │ │ │ @@ -101,15 +101,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01484.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Attributes | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::has_node_tag< T >::no Struct Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Attributes

    char dummy [2]
     
    │ │ │ │

    Member Data Documentation

    │ │ │ │ @@ -101,15 +101,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01488.html │ │ │ │ @@ -78,15 +78,15 @@ │ │ │ │ Static Public Member Functions | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::has_node_tag_value< T, V > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -193,15 +193,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    True if class T defines a NodeTag of type V.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01492.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Attributes | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::has_node_tag_value< T, V >::maybe< N > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │

    │ │ │ │ Classes

    struct  maybe
     
    struct  no
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Attributes

    char dummy [N+1]
     
    │ │ │ │

    Member Data Documentation

    │ │ │ │ @@ -103,15 +103,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01496.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Attributes | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::has_node_tag_value< T, V >::yes Struct Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Attributes

    char dummy [2]
     
    │ │ │ │

    Member Data Documentation

    │ │ │ │ @@ -101,15 +101,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01500.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Attributes | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::has_node_tag_value< T, V >::no Struct Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Attributes

    char dummy [1]
     
    │ │ │ │

    Member Data Documentation

    │ │ │ │ @@ -101,15 +101,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01504.html │ │ │ │ @@ -78,15 +78,15 @@ │ │ │ │ Static Public Member Functions | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::has_implementation_tag< T > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -191,15 +191,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    True if class T defines an ImplementationTag.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01508.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Attributes | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::has_implementation_tag< T >::yes Struct Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │

    │ │ │ │ Classes

    struct  no
     
    struct  yes
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Attributes

    char dummy [1]
     
    │ │ │ │

    Member Data Documentation

    │ │ │ │ @@ -101,15 +101,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01512.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Attributes | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::has_implementation_tag< T >::no Struct Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Attributes

    char dummy [2]
     
    │ │ │ │

    Member Data Documentation

    │ │ │ │ @@ -101,15 +101,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01516.html │ │ │ │ @@ -78,15 +78,15 @@ │ │ │ │ Static Public Member Functions | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::has_implementation_tag_value< T, V > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -193,15 +193,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    True if class T defines an ImplementationTag of type V.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01520.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Attributes | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::has_implementation_tag_value< T, V >::maybe< N > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │

    │ │ │ │ Classes

    struct  maybe
     
    struct  no
     
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Attributes

    char dummy [N+1]
     
    │ │ │ │

    Member Data Documentation

    │ │ │ │ @@ -103,15 +103,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01524.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Attributes | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::has_implementation_tag_value< T, V >::yes Struct Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Attributes

    char dummy [2]
     
    │ │ │ │

    Member Data Documentation

    │ │ │ │ @@ -101,15 +101,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01528.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Attributes | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::has_implementation_tag_value< T, V >::no Struct Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Attributes

    char dummy [1]
     
    │ │ │ │

    Member Data Documentation

    │ │ │ │ @@ -101,15 +101,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01532.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    │ │ │ │ Public Types | │ │ │ │ List of all members
    │ │ │ │
    Dune::TypeTree::AlwaysVoid< typename > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef void type
     
    │ │ │ │

    Member Typedef Documentation

    │ │ │ │ @@ -101,15 +101,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01536.html │ │ │ │ @@ -76,20 +76,20 @@ │ │ │ │
    Dune::TypeTree::meta_function Struct Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Marker tag declaring a meta function. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │

    Detailed Description

    │ │ │ │

    Marker tag declaring a meta function.

    │ │ │ │

    Just inherit from this type to cause lazy evaluation

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01540.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::lazy_evaluate< F > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Helper meta function to delay evaluation of F. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef F::type type
     
    │ │ │ │

    Detailed Description

    │ │ │ │ @@ -107,15 +107,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01544.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::lazy_identity< F > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Identity function. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef F type
     
    │ │ │ │

    Detailed Description

    │ │ │ │ @@ -107,15 +107,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01548.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::evaluate_if_meta_function< F > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Meta function that evaluates its argument iff it inherits from meta_function. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Public Types

    typedef std::conditional< std::is_base_of< meta_function, F >::value, lazy_evaluate< F >, lazy_identity< F > >::type::type type
     
    │ │ │ │

    Detailed Description

    │ │ │ │ @@ -107,15 +107,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01552.html │ │ │ │ @@ -76,15 +76,15 @@ │ │ │ │
    Dune::TypeTree::IsTreePath< T > Struct Template Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Check if type represents a tree path. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/typetraits.hh>

    │ │ │ │ +

    #include <dune/typetree/typetraits.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::IsTreePath< T >:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -98,15 +98,15 @@ │ │ │ │
    Template Parameters
    │ │ │ │ │ │ │ │ │ │ │ │
    TCheck if this type represents a tree path
    │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01556.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::TreeInfo< Tree, Tag > Struct Template Reference
    dune-typetree
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Struct for obtaining some basic structural information about a TypeTree. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/utility.hh>

    │ │ │ │ +

    #include <dune/typetree/utility.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -184,15 +184,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    The total number of nodes in the TypeTree.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01560.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::DefaultVisitor Struct Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Visitor interface and base class for TypeTree visitors. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/visitor.hh>

    │ │ │ │ +

    #include <dune/typetree/visitor.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::DefaultVisitor:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -451,15 +451,15 @@ │ │ │ │

    │ │ │ │ Static Public Attributes

    static const std::size_t depth = NodeInfo::depth
     The depth of the TypeTree.
     
    static const std::size_t nodeCount = NodeInfo::nodeCount
    │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01564.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::DefaultPairVisitor Struct Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Visitor interface and base class for visitors of pairs of TypeTrees. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/visitor.hh>

    │ │ │ │ +

    #include <dune/typetree/visitor.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::DefaultPairVisitor:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -514,15 +514,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01568.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::Experimental::DefaultHybridVisitor Struct Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Hybrid visitor interface and base class for TypeTree hybrid visitors. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/visitor.hh>

    │ │ │ │ +

    #include <dune/typetree/visitor.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::Experimental::DefaultHybridVisitor:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -501,15 +501,15 @@ │ │ │ │ │ │ │ │ │ │ │ │
    Returns
    The result of applying this visitor to u.
    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01572.html │ │ │ │ @@ -78,15 +78,15 @@ │ │ │ │
    Dune::TypeTree::VisitDirectChildren Struct Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Mixin base class for visitors that only want to visit the direct children of a node. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/visitor.hh>

    │ │ │ │ +

    #include <dune/typetree/visitor.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::VisitDirectChildren:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -102,15 +102,15 @@ │ │ │ │  Template struct for determining whether or not to visit a given child. More...
    │ │ │ │   │ │ │ │ │ │ │ │

    Detailed Description

    │ │ │ │

    Mixin base class for visitors that only want to visit the direct children of a node.

    │ │ │ │

    This mixin class will reject all children presented to it, causing the algorithm to only visit the root node and call DefaultVisitor::beforeChild() and DefaultVisitor::afterChild() for its direct children.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01576.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::VisitDirectChildren::VisitChild< Node1, Child1, Node2, Child2, TreePath > Struct Template Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │

    Template struct for determining whether or not to visit a given child. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/visitor.hh>

    │ │ │ │ +

    #include <dune/typetree/visitor.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Static Public Attributes

    static const bool value = false
     Do not visit any child.
     
    │ │ │ │ @@ -118,15 +118,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Do not visit any child.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01580.html │ │ │ │ @@ -78,15 +78,15 @@ │ │ │ │
    Dune::TypeTree::VisitTree Struct Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Mixin base class for visitors that want to visit the complete tree. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/visitor.hh>

    │ │ │ │ +

    #include <dune/typetree/visitor.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::VisitTree:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -108,15 +108,15 @@ │ │ │ │  Template struct for determining whether or not to visit a given child. More...
    │ │ │ │   │ │ │ │ │ │ │ │

    Detailed Description

    │ │ │ │

    Mixin base class for visitors that want to visit the complete tree.

    │ │ │ │

    This mixin class will accept all children presented to it and thus make the iterator traverse the entire tree.

    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01584.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::VisitTree::VisitChild< Node1, Child1, Node2, Child2, TreePath > Struct Template Reference
    │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │

    Template struct for determining whether or not to visit a given child. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/visitor.hh>

    │ │ │ │ +

    #include <dune/typetree/visitor.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Static Public Attributes

    static const bool value = true
     Visit any child.
     
    │ │ │ │ @@ -118,15 +118,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Visit any child.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01588.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::StaticTraversal Struct Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Mixin base class for visitors that require a static TreePath during traversal. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/visitor.hh>

    │ │ │ │ +

    #include <dune/typetree/visitor.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::StaticTraversal:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -131,15 +131,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Use the static tree traversal algorithm.

    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01592.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::DynamicTraversal Struct Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Mixin base class for visitors that only need a dynamic TreePath during traversal. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/visitor.hh>

    │ │ │ │ +

    #include <dune/typetree/visitor.hh>

    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    │ │ │ │ Static Public Attributes

    static const TreePathType::Type treePathType = TreePathType::dynamic
     Use the dynamic tree traversal algorithm.
     
    │ │ │ │ @@ -117,15 +117,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Use the dynamic tree traversal algorithm.

    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01596.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::TreeVisitor Struct Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Convenience base class for visiting the entire tree. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/visitor.hh>

    │ │ │ │ +

    #include <dune/typetree/visitor.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::TreeVisitor:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -442,15 +442,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01600.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::DirectChildrenVisitor Struct Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Convenience base class for visiting the direct children of a node. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/visitor.hh>

    │ │ │ │ +

    #include <dune/typetree/visitor.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::DirectChildrenVisitor:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -442,15 +442,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01604.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::TreePairVisitor Struct Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Convenience base class for visiting an entire tree pair. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/visitor.hh>

    │ │ │ │ +

    #include <dune/typetree/visitor.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::TreePairVisitor:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -499,15 +499,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01608.html │ │ │ │ @@ -79,15 +79,15 @@ │ │ │ │
    Dune::TypeTree::DirectChildrenPairVisitor Struct Reference
    dune-typetree » Traversal
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │

    Convenience base class for visiting the direct children of a node pair. │ │ │ │ More...

    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/visitor.hh>

    │ │ │ │ +

    #include <dune/typetree/visitor.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::DirectChildrenPairVisitor:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -499,15 +499,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01612.html │ │ │ │ @@ -77,15 +77,15 @@ │ │ │ │ Public Member Functions | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::Experimental::Info::LeafCounterVisitor Struct Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/visitor.hh>

    │ │ │ │ +

    #include <dune/typetree/visitor.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::Experimental::Info::LeafCounterVisitor:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -686,15 +686,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Use the static tree traversal algorithm.

    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01616.html │ │ │ │ @@ -77,15 +77,15 @@ │ │ │ │ Public Member Functions | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::Experimental::Info::NodeCounterVisitor Struct Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/visitor.hh>

    │ │ │ │ +

    #include <dune/typetree/visitor.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::Experimental::Info::NodeCounterVisitor:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -733,15 +733,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Use the static tree traversal algorithm.

    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/a01620.html │ │ │ │ @@ -77,15 +77,15 @@ │ │ │ │ Public Member Functions | │ │ │ │ Static Public Attributes | │ │ │ │ List of all members │ │ │ │
    Dune::TypeTree::Experimental::Info::DepthVisitor Struct Reference
    │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ -

    #include <dune/typetree/visitor.hh>

    │ │ │ │ +

    #include <dune/typetree/visitor.hh>

    │ │ │ │
    │ │ │ │ Inheritance diagram for Dune::TypeTree::Experimental::Info::DepthVisitor:
    │ │ │ │
    │ │ │ │
    Inheritance graph
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ @@ -566,15 +566,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │

    Use the static tree traversal algorithm.

    │ │ │ │ │ │ │ │
    │ │ │ │
    │ │ │ │
    The documentation for this struct was generated from the following file: │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/dir_5e74c06688912037f4b476b8dc05fab9.html │ │ │ │ @@ -84,68 +84,68 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │

    │ │ │ │ Files

     accumulate_static.hh
     accumulate_static.hh
     
     childextraction.hh
     childextraction.hh
     
     compositenode.hh
     compositenode.hh
     
     dynamicpowernode.hh
     dynamicpowernode.hh
     
     exceptions.hh
     TypeTree-specific exceptions.
     exceptions.hh
     TypeTree-specific exceptions.
     
     filteredcompositenode.hh
     filteredcompositenode.hh
     
     filters.hh
     filters.hh
     
     fixedcapacitystack.hh
     fixedcapacitystack.hh
     
     generictransformationdescriptors.hh
     generictransformationdescriptors.hh
     
     leafnode.hh
     leafnode.hh
     
     nodeinterface.hh
     nodeinterface.hh
     
     nodetags.hh
     nodetags.hh
     
     pairtraversal.hh
     pairtraversal.hh
     
     powercompositenodetransformationtemplates.hh
     powercompositenodetransformationtemplates.hh
     
     powernode.hh
     powernode.hh
     
     proxynode.hh
     proxynode.hh
     
     simpletransformationdescriptors.hh
     simpletransformationdescriptors.hh
     
     transformation.hh
     transformation.hh
     
     transformationutilities.hh
     transformationutilities.hh
     
     traversal.hh
     traversal.hh
     
     traversalutilities.hh
     traversalutilities.hh
     
     treecontainer.hh
     treecontainer.hh
     
     treepath.hh
     treepath.hh
     
     typetraits.hh
     typetraits.hh
     
     typetree.hh
     typetree.hh
     
     utility.hh
     utility.hh
     
     visitor.hh
     visitor.hh
     
    │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/dune-typetree.tag.gz │ │ │ │ ├── dune-typetree.tag │ │ │ │ │ ├── dune-typetree.tag │ │ │ │ │ │ @@ -9,19 +9,19 @@ │ │ │ │ │ │ modules.txt │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/doc/doxygen/ │ │ │ │ │ │ a00005.html │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ accumulate_static.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00032.html │ │ │ │ │ │ - dune/typetree/nodeinterface.hh │ │ │ │ │ │ - dune/typetree/nodetags.hh │ │ │ │ │ │ - dune/typetree/treepath.hh │ │ │ │ │ │ - dune/typetree/utility.hh │ │ │ │ │ │ + a00023.html │ │ │ │ │ │ + dune/typetree/nodeinterface.hh │ │ │ │ │ │ + dune/typetree/nodetags.hh │ │ │ │ │ │ + dune/typetree/treepath.hh │ │ │ │ │ │ + dune/typetree/utility.hh │ │ │ │ │ │ Dune::TypeTree::or_ │ │ │ │ │ │ Dune::TypeTree::or_::reduce │ │ │ │ │ │ Dune::TypeTree::and_ │ │ │ │ │ │ Dune::TypeTree::and_::reduce │ │ │ │ │ │ Dune::TypeTree::plus │ │ │ │ │ │ Dune::TypeTree::plus::reduce │ │ │ │ │ │ Dune::TypeTree::minus │ │ │ │ │ │ @@ -37,81 +37,81 @@ │ │ │ │ │ │ Dune::TypeTree::AccumulateType │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ Dune::TypeTree::Experimental │ │ │ │ │ │ │ │ │ │ │ │ static const result_type │ │ │ │ │ │ result │ │ │ │ │ │ - a00032.html │ │ │ │ │ │ + a00023.html │ │ │ │ │ │ acd23380b12c1509b3b3f31b893af75c8 │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ static const result_type │ │ │ │ │ │ child_result │ │ │ │ │ │ - a00032.html │ │ │ │ │ │ + a00023.html │ │ │ │ │ │ a5c902ae13e1b03f88e252f9fd9f85952 │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ childextraction.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00053.html │ │ │ │ │ │ - dune/typetree/nodeinterface.hh │ │ │ │ │ │ - dune/typetree/treepath.hh │ │ │ │ │ │ + a00008.html │ │ │ │ │ │ + dune/typetree/nodeinterface.hh │ │ │ │ │ │ + dune/typetree/treepath.hh │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ compositenode.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00026.html │ │ │ │ │ │ - dune/typetree/nodetags.hh │ │ │ │ │ │ - dune/typetree/childextraction.hh │ │ │ │ │ │ - dune/typetree/typetraits.hh │ │ │ │ │ │ + a00044.html │ │ │ │ │ │ + dune/typetree/nodetags.hh │ │ │ │ │ │ + dune/typetree/childextraction.hh │ │ │ │ │ │ + dune/typetree/typetraits.hh │ │ │ │ │ │ Dune::TypeTree::CompositeNode │ │ │ │ │ │ Dune::TypeTree::CompositeNode::Child │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ dynamicpowernode.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00077.html │ │ │ │ │ │ - dune/typetree/nodetags.hh │ │ │ │ │ │ - dune/typetree/utility.hh │ │ │ │ │ │ - dune/typetree/typetraits.hh │ │ │ │ │ │ + a00026.html │ │ │ │ │ │ + dune/typetree/nodetags.hh │ │ │ │ │ │ + dune/typetree/utility.hh │ │ │ │ │ │ + dune/typetree/typetraits.hh │ │ │ │ │ │ Dune::TypeTree::DynamicPowerNode │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ exceptions.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00086.html │ │ │ │ │ │ + a00041.html │ │ │ │ │ │ Dune::TypeTree::Exception │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ filteredcompositenode.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00071.html │ │ │ │ │ │ - dune/typetree/nodetags.hh │ │ │ │ │ │ - dune/typetree/filters.hh │ │ │ │ │ │ + a00083.html │ │ │ │ │ │ + dune/typetree/nodetags.hh │ │ │ │ │ │ + dune/typetree/filters.hh │ │ │ │ │ │ Dune::TypeTree::FilteredCompositeNode │ │ │ │ │ │ Dune::TypeTree::FilteredCompositeNode::Child │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ filters.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00074.html │ │ │ │ │ │ + a00047.html │ │ │ │ │ │ Dune::TypeTree::FilterEntry │ │ │ │ │ │ Dune::TypeTree::FilterResult │ │ │ │ │ │ Dune::TypeTree::FilterResult::apply │ │ │ │ │ │ Dune::TypeTree::SimpleFilterTag │ │ │ │ │ │ Dune::TypeTree::AdvancedFilterTag │ │ │ │ │ │ Dune::TypeTree::AdvancedFilter │ │ │ │ │ │ Dune::TypeTree::AdvancedFilter::apply │ │ │ │ │ │ @@ -123,27 +123,27 @@ │ │ │ │ │ │ Dune::TypeTree::filter::apply │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ fixedcapacitystack.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00023.html │ │ │ │ │ │ + a00029.html │ │ │ │ │ │ Dune::TypeTree::FixedCapacityStackView │ │ │ │ │ │ Dune::TypeTree::FixedCapacityStack │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ generictransformationdescriptors.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00062.html │ │ │ │ │ │ - dune/typetree/nodeinterface.hh │ │ │ │ │ │ - dune/typetree/nodetags.hh │ │ │ │ │ │ - dune/typetree/powercompositenodetransformationtemplates.hh │ │ │ │ │ │ + a00068.html │ │ │ │ │ │ + dune/typetree/nodeinterface.hh │ │ │ │ │ │ + dune/typetree/nodetags.hh │ │ │ │ │ │ + dune/typetree/powercompositenodetransformationtemplates.hh │ │ │ │ │ │ Dune::TypeTree::GenericLeafNodeTransformation │ │ │ │ │ │ Dune::TypeTree::TemplatizedGenericPowerNodeTransformation │ │ │ │ │ │ Dune::TypeTree::TemplatizedGenericPowerNodeTransformation::result │ │ │ │ │ │ Dune::TypeTree::GenericPowerNodeTransformation │ │ │ │ │ │ Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation │ │ │ │ │ │ Dune::TypeTree::TemplatizedGenericDynamicPowerNodeTransformation::result │ │ │ │ │ │ Dune::TypeTree::GenericDynamicPowerNodeTransformation │ │ │ │ │ │ @@ -152,197 +152,197 @@ │ │ │ │ │ │ Dune::TypeTree::GenericCompositeNodeTransformation │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ leafnode.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00068.html │ │ │ │ │ │ - dune/typetree/nodetags.hh │ │ │ │ │ │ + a00071.html │ │ │ │ │ │ + dune/typetree/nodetags.hh │ │ │ │ │ │ Dune::TypeTree::LeafNode │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ nodeinterface.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00029.html │ │ │ │ │ │ + a00053.html │ │ │ │ │ │ Dune::TypeTree::NodeInterface │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ nodetags.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00056.html │ │ │ │ │ │ + a00050.html │ │ │ │ │ │ Dune::TypeTree::LeafNodeTag │ │ │ │ │ │ Dune::TypeTree::PowerNodeTag │ │ │ │ │ │ Dune::TypeTree::DynamicPowerNodeTag │ │ │ │ │ │ Dune::TypeTree::CompositeNodeTag │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ pairtraversal.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00065.html │ │ │ │ │ │ - dune/typetree/nodeinterface.hh │ │ │ │ │ │ - dune/typetree/nodetags.hh │ │ │ │ │ │ - dune/typetree/treepath.hh │ │ │ │ │ │ - dune/typetree/visitor.hh │ │ │ │ │ │ - dune/typetree/traversal.hh │ │ │ │ │ │ + a00038.html │ │ │ │ │ │ + dune/typetree/nodeinterface.hh │ │ │ │ │ │ + dune/typetree/nodetags.hh │ │ │ │ │ │ + dune/typetree/treepath.hh │ │ │ │ │ │ + dune/typetree/visitor.hh │ │ │ │ │ │ + dune/typetree/traversal.hh │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ Dune::TypeTree::Detail │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ powercompositenodetransformationtemplates.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00017.html │ │ │ │ │ │ - dune/typetree/nodeinterface.hh │ │ │ │ │ │ + a00086.html │ │ │ │ │ │ + dune/typetree/nodeinterface.hh │ │ │ │ │ │ Dune::TypeTree::GenericPowerNodeTransformationTemplate │ │ │ │ │ │ Dune::TypeTree::GenericPowerNodeTransformationTemplate::result │ │ │ │ │ │ Dune::TypeTree::GenericDynamicPowerNodeTransformationTemplate │ │ │ │ │ │ Dune::TypeTree::GenericDynamicPowerNodeTransformationTemplate::result │ │ │ │ │ │ Dune::TypeTree::GenericCompositeNodeTransformationTemplate │ │ │ │ │ │ Dune::TypeTree::GenericCompositeNodeTransformationTemplate::result │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ powernode.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00038.html │ │ │ │ │ │ - dune/typetree/nodetags.hh │ │ │ │ │ │ - dune/typetree/utility.hh │ │ │ │ │ │ - dune/typetree/childextraction.hh │ │ │ │ │ │ - dune/typetree/typetraits.hh │ │ │ │ │ │ + a00011.html │ │ │ │ │ │ + dune/typetree/nodetags.hh │ │ │ │ │ │ + dune/typetree/utility.hh │ │ │ │ │ │ + dune/typetree/childextraction.hh │ │ │ │ │ │ + dune/typetree/typetraits.hh │ │ │ │ │ │ Dune::TypeTree::PowerNode │ │ │ │ │ │ Dune::TypeTree::PowerNode::Child │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ proxynode.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00008.html │ │ │ │ │ │ - dune/typetree/nodeinterface.hh │ │ │ │ │ │ - dune/typetree/nodetags.hh │ │ │ │ │ │ + a00080.html │ │ │ │ │ │ + dune/typetree/nodeinterface.hh │ │ │ │ │ │ + dune/typetree/nodetags.hh │ │ │ │ │ │ Dune::TypeTree::StaticChildAccessors │ │ │ │ │ │ Dune::TypeTree::StaticChildAccessors::Child │ │ │ │ │ │ Dune::TypeTree::DynamicChildAccessors │ │ │ │ │ │ Dune::TypeTree::ProxyNodeBase< Node, LeafNodeTag > │ │ │ │ │ │ Dune::TypeTree::ProxyNodeBase< Node, CompositeNodeTag > │ │ │ │ │ │ Dune::TypeTree::ProxyNodeBase< Node, PowerNodeTag > │ │ │ │ │ │ Dune::TypeTree::ProxyNodeBase< Node, DynamicPowerNodeTag > │ │ │ │ │ │ Dune::TypeTree::ProxyNode │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ simpletransformationdescriptors.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00035.html │ │ │ │ │ │ - dune/typetree/nodeinterface.hh │ │ │ │ │ │ - dune/typetree/nodetags.hh │ │ │ │ │ │ + a00065.html │ │ │ │ │ │ + dune/typetree/nodeinterface.hh │ │ │ │ │ │ + dune/typetree/nodetags.hh │ │ │ │ │ │ Dune::TypeTree::SimpleLeafNodeTransformation │ │ │ │ │ │ Dune::TypeTree::SimplePowerNodeTransformation │ │ │ │ │ │ Dune::TypeTree::SimplePowerNodeTransformation::result │ │ │ │ │ │ Dune::TypeTree::SimpleDynamicPowerNodeTransformation │ │ │ │ │ │ Dune::TypeTree::SimpleDynamicPowerNodeTransformation::result │ │ │ │ │ │ Dune::TypeTree::SimpleCompositeNodeTransformation │ │ │ │ │ │ Dune::TypeTree::SimpleCompositeNodeTransformation::result │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ transformation.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00020.html │ │ │ │ │ │ - dune/typetree/typetraits.hh │ │ │ │ │ │ - dune/typetree/nodeinterface.hh │ │ │ │ │ │ - dune/typetree/nodetags.hh │ │ │ │ │ │ - dune/typetree/utility.hh │ │ │ │ │ │ + a00077.html │ │ │ │ │ │ + dune/typetree/typetraits.hh │ │ │ │ │ │ + dune/typetree/nodeinterface.hh │ │ │ │ │ │ + dune/typetree/nodetags.hh │ │ │ │ │ │ + dune/typetree/utility.hh │ │ │ │ │ │ Dune::TypeTree::TransformTree │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ transformationutilities.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00050.html │ │ │ │ │ │ - dune/typetree/simpletransformationdescriptors.hh │ │ │ │ │ │ - dune/typetree/generictransformationdescriptors.hh │ │ │ │ │ │ + a00020.html │ │ │ │ │ │ + dune/typetree/simpletransformationdescriptors.hh │ │ │ │ │ │ + dune/typetree/generictransformationdescriptors.hh │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ traversal.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00080.html │ │ │ │ │ │ - dune/typetree/childextraction.hh │ │ │ │ │ │ - dune/typetree/nodetags.hh │ │ │ │ │ │ - dune/typetree/treepath.hh │ │ │ │ │ │ - dune/typetree/visitor.hh │ │ │ │ │ │ + a00059.html │ │ │ │ │ │ + dune/typetree/childextraction.hh │ │ │ │ │ │ + dune/typetree/nodetags.hh │ │ │ │ │ │ + dune/typetree/treepath.hh │ │ │ │ │ │ + dune/typetree/visitor.hh │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ Dune::TypeTree::Detail │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ traversalutilities.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00083.html │ │ │ │ │ │ - dune/typetree/traversal.hh │ │ │ │ │ │ + a00056.html │ │ │ │ │ │ + dune/typetree/traversal.hh │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ │ │ │ │ │ │ static const TreePathType::Type │ │ │ │ │ │ treePathType │ │ │ │ │ │ - a00083.html │ │ │ │ │ │ + a00056.html │ │ │ │ │ │ ac933f134e17da9e8dbf18be15134df40 │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ F │ │ │ │ │ │ _functor │ │ │ │ │ │ - a00083.html │ │ │ │ │ │ + a00056.html │ │ │ │ │ │ a925ce4fb47f35dbaf1550d896578184f │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ R │ │ │ │ │ │ _reduction │ │ │ │ │ │ - a00083.html │ │ │ │ │ │ + a00056.html │ │ │ │ │ │ a3399305aa17d4bcec74944e962ff3a12 │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ResultType │ │ │ │ │ │ _value │ │ │ │ │ │ - a00083.html │ │ │ │ │ │ + a00056.html │ │ │ │ │ │ ad4dc401736cbecb52f1afd1c8c8d359f │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ treecontainer.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00014.html │ │ │ │ │ │ - dune/typetree/treepath.hh │ │ │ │ │ │ + a00017.html │ │ │ │ │ │ + dune/typetree/treepath.hh │ │ │ │ │ │ Dune::TypeTree::Detail::ContainerFactory │ │ │ │ │ │ Dune::TypeTree::Detail::TreeContainerVectorBackend │ │ │ │ │ │ Dune::TypeTree::Detail::LeafToDefaultConstructibleValue │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ Dune::TypeTree::Detail │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ treepath.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00041.html │ │ │ │ │ │ - dune/typetree/fixedcapacitystack.hh │ │ │ │ │ │ - dune/typetree/utility.hh │ │ │ │ │ │ + a00062.html │ │ │ │ │ │ + dune/typetree/fixedcapacitystack.hh │ │ │ │ │ │ + dune/typetree/utility.hh │ │ │ │ │ │ Dune::TypeTree::HybridTreePath │ │ │ │ │ │ Dune::TypeTree::TreePathSize< HybridTreePath< index_constant< i >... > > │ │ │ │ │ │ Dune::TypeTree::TreePathPushBack< HybridTreePath< index_constant< i >... >, k > │ │ │ │ │ │ Dune::TypeTree::TreePathPushFront< HybridTreePath< index_constant< i >... >, k > │ │ │ │ │ │ Dune::TypeTree::TreePathBack< HybridTreePath< index_constant< k > > > │ │ │ │ │ │ Dune::TypeTree::TreePathBack< HybridTreePath< index_constant< j >, index_constant< k >, index_constant< l >... > > │ │ │ │ │ │ Dune::TypeTree::TreePathFront< HybridTreePath< index_constant< k >, index_constant< i >... > > │ │ │ │ │ │ @@ -354,17 +354,17 @@ │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ Dune::TypeTree::TreePathType │ │ │ │ │ │ Dune::TypeTree::Literals │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ typetraits.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00044.html │ │ │ │ │ │ - dune/typetree/treepath.hh │ │ │ │ │ │ - dune/typetree/nodeinterface.hh │ │ │ │ │ │ + a00014.html │ │ │ │ │ │ + dune/typetree/treepath.hh │ │ │ │ │ │ + dune/typetree/nodeinterface.hh │ │ │ │ │ │ Dune::first_type< T0, T... > │ │ │ │ │ │ Dune::TypeTree::has_node_tag │ │ │ │ │ │ Dune::TypeTree::has_node_tag::yes │ │ │ │ │ │ Dune::TypeTree::has_node_tag::no │ │ │ │ │ │ Dune::TypeTree::has_node_tag_value │ │ │ │ │ │ Dune::TypeTree::has_node_tag_value::maybe │ │ │ │ │ │ Dune::TypeTree::has_node_tag_value::yes │ │ │ │ │ │ @@ -385,44 +385,44 @@ │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ Dune::TypeTree::impl │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ typetree.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00059.html │ │ │ │ │ │ - dune/typetree/nodetags.hh │ │ │ │ │ │ - dune/typetree/utility.hh │ │ │ │ │ │ - dune/typetree/leafnode.hh │ │ │ │ │ │ - dune/typetree/powernode.hh │ │ │ │ │ │ - dune/typetree/dynamicpowernode.hh │ │ │ │ │ │ - dune/typetree/compositenode.hh │ │ │ │ │ │ - dune/typetree/traversal.hh │ │ │ │ │ │ - dune/typetree/pairtraversal.hh │ │ │ │ │ │ - dune/typetree/traversalutilities.hh │ │ │ │ │ │ - dune/typetree/transformation.hh │ │ │ │ │ │ - dune/typetree/transformationutilities.hh │ │ │ │ │ │ - dune/typetree/accumulate_static.hh │ │ │ │ │ │ - dune/typetree/childextraction.hh │ │ │ │ │ │ + a00032.html │ │ │ │ │ │ + dune/typetree/nodetags.hh │ │ │ │ │ │ + dune/typetree/utility.hh │ │ │ │ │ │ + dune/typetree/leafnode.hh │ │ │ │ │ │ + dune/typetree/powernode.hh │ │ │ │ │ │ + dune/typetree/dynamicpowernode.hh │ │ │ │ │ │ + dune/typetree/compositenode.hh │ │ │ │ │ │ + dune/typetree/traversal.hh │ │ │ │ │ │ + dune/typetree/pairtraversal.hh │ │ │ │ │ │ + dune/typetree/traversalutilities.hh │ │ │ │ │ │ + dune/typetree/transformation.hh │ │ │ │ │ │ + dune/typetree/transformationutilities.hh │ │ │ │ │ │ + dune/typetree/accumulate_static.hh │ │ │ │ │ │ + dune/typetree/childextraction.hh │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ utility.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00047.html │ │ │ │ │ │ - dune/typetree/nodeinterface.hh │ │ │ │ │ │ - dune/typetree/nodetags.hh │ │ │ │ │ │ + a00035.html │ │ │ │ │ │ + dune/typetree/nodeinterface.hh │ │ │ │ │ │ + dune/typetree/nodetags.hh │ │ │ │ │ │ Dune::TypeTree::TreeInfo │ │ │ │ │ │ Dune │ │ │ │ │ │ Dune::TypeTree │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ visitor.hh │ │ │ │ │ │ /build/reproducible-path/dune-typetree-2.10.0/dune/typetree/ │ │ │ │ │ │ - a00011.html │ │ │ │ │ │ - dune/typetree/treepath.hh │ │ │ │ │ │ + a00074.html │ │ │ │ │ │ + dune/typetree/treepath.hh │ │ │ │ │ │ Dune::TypeTree::DefaultVisitor │ │ │ │ │ │ Dune::TypeTree::DefaultPairVisitor │ │ │ │ │ │ Dune::TypeTree::Experimental::DefaultHybridVisitor │ │ │ │ │ │ Dune::TypeTree::VisitDirectChildren │ │ │ │ │ │ Dune::TypeTree::VisitDirectChildren::VisitChild │ │ │ │ │ │ Dune::TypeTree::VisitTree │ │ │ │ │ │ Dune::TypeTree::VisitTree::VisitChild │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/files.html │ │ │ │ @@ -74,41 +74,41 @@ │ │ │ │
    │ │ │ │
    Here is a list of all files with brief descriptions:
    │ │ │ │
    [detail level 123]
    │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │
     ▼ doc
     doxygen
     ▼ dune
     ▼ typetree
     accumulate_static.hh
     childextraction.hh
     compositenode.hh
     dynamicpowernode.hh
     exceptions.hhTypeTree-specific exceptions
     filteredcompositenode.hh
     filters.hh
     fixedcapacitystack.hh
     generictransformationdescriptors.hh
     leafnode.hh
     nodeinterface.hh
     nodetags.hh
     pairtraversal.hh
     powercompositenodetransformationtemplates.hh
     powernode.hh
     proxynode.hh
     simpletransformationdescriptors.hh
     transformation.hh
     transformationutilities.hh
     traversal.hh
     traversalutilities.hh
     treecontainer.hh
     treepath.hh
     typetraits.hh
     typetree.hh
     utility.hh
     visitor.hh
     accumulate_static.hh
     childextraction.hh
     compositenode.hh
     dynamicpowernode.hh
     exceptions.hhTypeTree-specific exceptions
     filteredcompositenode.hh
     filters.hh
     fixedcapacitystack.hh
     generictransformationdescriptors.hh
     leafnode.hh
     nodeinterface.hh
     nodetags.hh
     pairtraversal.hh
     powercompositenodetransformationtemplates.hh
     powernode.hh
     proxynode.hh
     simpletransformationdescriptors.hh
     transformation.hh
     transformationutilities.hh
     traversal.hh
     traversalutilities.hh
     treecontainer.hh
     treepath.hh
     typetraits.hh
     typetree.hh
     utility.hh
     visitor.hh
    │ │ │ │
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/globals.html │ │ │ │ @@ -66,20 +66,20 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    Here is a list of all file members with links to the files they belong to:
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │ │ │ │ ├── ./usr/share/doc/libdune-typetree-doc/doxygen/globals_vars.html │ │ │ │ @@ -66,20 +66,20 @@ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
    │ │ │ │
    Here is a list of all variables with links to the files they belong to:
    │ │ │ │
    │ │ │ │ │ │ │ │
    │ │ │ │ Generated by doxygen 1.9.8 │ │ │ │
    │ │ │ │