DUNE PDELab (unstable)

treepath.hh
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_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
21namespace Dune {
22 namespace TypeTree {
23
24 // The Impl namespace collects some free standing functions helper functions
25 namespace Impl {
26 template<typename T>
27 struct check_size_t_impl
28 {
29 static constexpr auto check() {
30 return std::is_same_v<T, std::size_t>;
31 }
32 };
33
34 template<class T, T v>
35 struct check_size_t_impl<std::integral_constant<T,v>>
36 {
37 static constexpr auto check() {
38 return std::is_same_v<T, std::size_t>;
39 }
40 };
41
42 template<typename T>
43 constexpr auto check_size_t() {
44 return check_size_t_impl<T>::check();
45 }
46
47 template<typename T>
48 constexpr auto cast_size_t(const T & v) {
49 // check that T is an integral type that can be cast to std::size_t
50 static_assert(
51 std::is_convertible_v<T,std::size_t> &&
52 std::is_integral_v<T>,
53 "HybridTreePath indices must be convertible to std::size_t or std::integral_constant<std::size_t,v>");
54 // positivity can only be checked at run-time
55 assert(v >= 0 &&
56 "HybridTreePath indices must be convertible to std::size_t or std::integral_constant<std::size_t,v>");
57 return std::size_t(v);
58 }
59
60 template<class T, T v>
61 constexpr auto cast_size_t(std::integral_constant<T,v>) {
62 // check that T is an intergal type that can be cast to std::size_t
63 // and that v is positive
64 static_assert(
65 std::is_convertible_v<T,std::size_t> &&
66 std::is_integral_v<T> &&
67 v >= 0,
68 "HybridTreePath indices must be convertible to std::size_t or std::integral_constant<std::size_t,v>");
69 return std::integral_constant<std::size_t,v>();
70 }
71
72 // these are helper functions that help triggering a deprecation warning
73 template<typename T>
74 [[deprecated("HybridTreePath index storage should be std::size_t or std::integral_constant<std::size_t,v>!\n"
75 "Using anything else is deprecated and will not possible after the 2.10 release.\n"
76 "It is adviced not to specify the template parameters expicitly,\n"
77 "but to use the helper functions `hybridTreePath` or `treePath`."
78 "These take care of converting indices to the appropriate storage.")]]
79 constexpr bool check_storage_type(MetaType<T>) {
80 return false;
81 }
82
83 // specialization of valid index type
84 template<std::size_t v>
85 constexpr bool check_storage_type(MetaType<std::integral_constant<std::size_t,v>>) {
86 return true;
87 }
88
89 // specialization of valid index type
90 constexpr bool check_storage_type(MetaType<std::size_t>) {
91 return true;
92 }
93 }
94
95 template<typename... T>
96 class HybridTreePath;
97
101
102 namespace TreePathType {
103 enum Type { fullyStatic, dynamic };
104 }
105
106 template<typename>
107 struct TreePathSize;
108
109 template<typename,std::size_t>
110 struct TreePathPushBack;
111
112 template<typename,std::size_t>
113 struct TreePathPushFront;
114
115 template<typename>
116 struct TreePathBack;
117
118 template<typename>
119 struct TreePathFront;
120
121 template<typename, std::size_t...>
122 struct TreePathPopBack;
123
124 template<typename>
125 struct TreePathPopFront;
126
127 template<typename, typename>
128 struct TreePathConcat;
129
130 template<std::size_t... i>
131 void print_tree_path(std::ostream& os)
132 {}
133
134 template<std::size_t k, std::size_t... i>
135 void print_tree_path(std::ostream& os)
136 {
137 os << k << " ";
138 print_tree_path<i...>(os);
139 }
140
142
153 template<typename... T>
154 class HybridTreePath
155 {
156
157 // enable check for dune-typetree 2.10 and above
158#if DUNE_VERSION_GTE(TYPETREE,2,10)
159 // make sure that all indices use std::size_t as the underlying number type
160 static_assert((... && Impl::check_size_t<T>()),
161 "HybridTreePath index storage must be std::size_t or std::integral_constant<std::size_t,v>");
162#endif
163
164 public:
165
167 using index_sequence = std::index_sequence_for<T...>;
168
170 constexpr HybridTreePath()
171 {
172 [[maybe_unused]] constexpr bool check =
173 (... && Impl::check_storage_type(MetaType<T>()) );
174 }
175
176 constexpr HybridTreePath(const HybridTreePath& tp) = default;
177 constexpr HybridTreePath(HybridTreePath&& tp) = default;
178
179 constexpr HybridTreePath& operator=(const HybridTreePath& tp) = default;
180 constexpr HybridTreePath& operator=(HybridTreePath&& tp) = default;
181
183 explicit constexpr HybridTreePath(std::tuple<T...> t)
184 : _data(t)
185 {
186 [[maybe_unused]] constexpr bool check =
187 (... && Impl::check_storage_type(MetaType<T>()) );
188 }
189
191 template<typename... U,
192 typename std::enable_if_t<(sizeof...(T) > 0 && sizeof...(U) == sizeof...(T)),bool> = true>
193 explicit constexpr HybridTreePath(U... t)
194 : _data(t...) // we assume that all arguments are convertible to the types T...
195 {
196 [[maybe_unused]] constexpr bool check =
197 (... && Impl::check_storage_type(MetaType<T>()) );
198 }
199
201 [[nodiscard]] constexpr static index_sequence enumerate()
202 {
203 return {};
204 }
205
207 [[nodiscard]] constexpr static std::size_t size()
208 {
209 return sizeof...(T);
210 }
211
213 [[nodiscard]] constexpr static std::size_t max_size()
214 {
215 return size();
216 }
217
219 template<std::size_t i,
220 std::enable_if_t<(sizeof...(T) > i),bool> = true>
221 [[nodiscard]] constexpr auto operator[](Dune::index_constant<i>) const
222 {
223 return std::get<i>(_data);
224 }
225
227 [[nodiscard]] constexpr std::size_t operator[](std::size_t pos) const
228 {
229 std::size_t entry = 0;
230 Dune::Hybrid::forEach(enumerate(), [&] (auto i) {
231 if (i==pos)
232 entry = this->element(i);
233 });
234 return entry;
235 }
236
238 template<std::size_t i,
239 std::enable_if_t<(sizeof...(T) > i),bool> = true>
240 [[nodiscard]] constexpr auto element(Dune::index_constant<i> pos = {}) const
241 {
242 return std::get<i>(_data);
243 }
244
246 [[nodiscard]] constexpr std::size_t element(std::size_t pos) const
247 {
248 std::size_t entry = 0;
249 Dune::Hybrid::forEach(enumerate(), [&] (auto i) {
250 if (i==pos)
251 entry = this->element(i);
252 });
253 return entry;
254 }
255
257 template<std::size_t n = sizeof...(T),
258 std::enable_if_t<(n > 0 && n == sizeof...(T)),bool> = true>
259 [[nodiscard]] constexpr auto front() const
260 {
261 return std::get<0>(_data);
262 }
263
265 template<std::size_t n = sizeof...(T),
266 std::enable_if_t<(n > 0 && n == sizeof...(T)),bool> = true>
267 [[nodiscard]] constexpr auto back() const
268 {
269 return std::get<n-1>(_data);
270 }
271
272#ifndef DOXYGEN
273
274 // I can't be bothered to make all the external accessors friends of HybridTreePath,
275 // so we'll only hide the data tuple from the user in Doxygen.
276
277 using Data = std::tuple<T...>;
278 Data _data;
279
280#endif // DOXYGEN
281
282 };
283
285
291 template<typename... T>
292 [[nodiscard]] constexpr auto makeTreePath(const T... t)
293 {
294 // check that all entries are based on std::size_t
295 static_assert((... && Impl::check_size_t<T>()),
296 "HybridTreePath indices must be of type std::size_t or std::integral_constant<std::size_t,v>");
297 return HybridTreePath<T...>(t...);
298 }
299
301
308 template<typename... T>
309 [[nodiscard]] constexpr auto hybridTreePath(const T&... t)
310 {
311 return makeTreePath(Impl::cast_size_t(t)...);
312 }
313
315
322 template<typename... T>
323 [[nodiscard]] constexpr auto treePath(const T&... t)
324 {
325 return makeTreePath(Impl::cast_size_t(t)...);
326 }
327
328
330 template<typename... T>
331 [[nodiscard]] constexpr std::size_t treePathSize(const HybridTreePath<T...>&)
332 {
333 return sizeof...(T);
334 }
335
337
353 template<std::size_t i, typename... T>
354 [[nodiscard]] constexpr auto treePathEntry(const HybridTreePath<T...>& tp, index_constant<i> = {})
355 -> typename std::decay<decltype(std::get<i>(tp._data))>::type
356 {
357 return std::get<i>(tp._data);
358 }
359
361
376 template<std::size_t i,typename... T>
377 [[nodiscard]] constexpr std::size_t treePathIndex(const HybridTreePath<T...>& tp, index_constant<i> = {})
378 {
379 return std::get<i>(tp._data);
380 }
381
383
388 template<typename... T>
389 [[nodiscard]] constexpr auto back(const HybridTreePath<T...>& tp)
390 -> decltype(tp.back())
391 {
392 return tp.back();
393 }
394
396
401 template<typename... T>
402 [[nodiscard]] constexpr auto front(const HybridTreePath<T...>& tp)
403 -> decltype(tp.front())
404 {
405 return tp.front();
406 }
407
409
412 template<typename... T>
413 [[nodiscard]] constexpr HybridTreePath<T...,std::size_t> push_back(const HybridTreePath<T...>& tp, std::size_t i)
414 {
415 return HybridTreePath<T...,std::size_t>(std::tuple_cat(tp._data,std::make_tuple(i)));
416 }
417
419
433 template<std::size_t i, typename... T>
434 [[nodiscard]] constexpr HybridTreePath<T...,index_constant<i>> push_back(const HybridTreePath<T...>& tp, index_constant<i> i_ = {})
435 {
436 return HybridTreePath<T...,index_constant<i> >(std::tuple_cat(tp._data,std::make_tuple(i_)));
437 }
438
440
443 template<typename... T>
444 [[nodiscard]] constexpr HybridTreePath<std::size_t,T...> push_front(const HybridTreePath<T...>& tp, std::size_t element)
445 {
446 return HybridTreePath<std::size_t,T...>(std::tuple_cat(std::make_tuple(element),tp._data));
447 }
448
450
464 template<std::size_t i, typename... T>
465 [[nodiscard]] constexpr HybridTreePath<index_constant<i>,T...> push_front(const HybridTreePath<T...>& tp, index_constant<i> _i = {})
466 {
467 return HybridTreePath<index_constant<i>,T...>(std::tuple_cat(std::make_tuple(_i),tp._data));
468 }
469
471
482 template<typename I, typename... T, std::enable_if_t<(sizeof...(T) > 0),bool> = true>
483 [[nodiscard]] constexpr auto accumulate_back(const HybridTreePath<T...>& tp, I i) {
484 using ::Dune::Hybrid::plus;
485 return push_back(pop_back(tp), plus(back(tp), i));
486 }
487
488
490
501 template<typename I, typename... T, std::enable_if_t<(sizeof...(T) > 0),bool> = true>
502 [[nodiscard]] constexpr auto accumulate_front(const HybridTreePath<T...>& tp, I i) {
503 using ::Dune::Hybrid::plus;
504 return push_front(pop_front(tp), plus(front(tp), i));
505 }
506
508 template<class... Head, class... Other>
509 [[nodiscard]] constexpr auto join(const HybridTreePath<Head...>& head, const Other&... tail) {
510 return TypeTree::HybridTreePath{std::tuple_cat(head._data, tail._data...)};
511 }
512
514 template<class... T>
515 [[nodiscard]] constexpr auto reverse(const HybridTreePath<T...>& tp) {
516 constexpr std::size_t size = sizeof...(T);
517 return unpackIntegerSequence([&](auto... i){
518 return treePath(tp[index_constant<size-i-1>{}] ...);
519 }, std::make_index_sequence<size>{});
520 }
521
523
526 template <class... T, std::enable_if_t<(sizeof...(T) > 0),bool> = true>
527 [[nodiscard]] constexpr auto pop_front(const HybridTreePath<T...>& tp)
528 {
529 return unpackIntegerSequence([&](auto... i){
530 return HybridTreePath{std::make_tuple(std::get<i+1>(tp._data)...)};
531 }, std::make_index_sequence<(sizeof...(T) - 1)>{});
532 }
533
535
538 template <class... T, std::enable_if_t<(sizeof...(T) > 0),bool> = true>
539 [[nodiscard]] constexpr auto pop_back(const HybridTreePath<T...>& tp)
540 {
541 return unpackIntegerSequence([&](auto... i){
542 return HybridTreePath{std::make_tuple(std::get<i>(tp._data)...)};
543 }, std::make_index_sequence<(sizeof...(T) - 1)>{});
544 }
545
547
555 template <class... S, class... T>
556 [[nodiscard]] constexpr bool operator==(
557 const HybridTreePath<S...>& lhs,
558 const HybridTreePath<T...>& rhs)
559 {
560 if constexpr (sizeof...(S) == sizeof...(T)) {
561 if constexpr ((Dune::IsInteroperable<S,T>::value &&...)) {
562 return unpackIntegerSequence([&](auto... i){
563 return ((std::get<i>(lhs._data) == std::get<i>(rhs._data)) &&...);
564 }, std::make_index_sequence<(sizeof...(S))>{});
565 } else {
566 return false;
567 }
568 } else {
569 return false;
570 }
571 }
572
574
579 template <class S, S... lhs, class T, T... rhs>
580 [[nodiscard]] constexpr auto operator==(
581 const HybridTreePath<std::integral_constant<S,lhs>...>&,
582 const HybridTreePath<std::integral_constant<T,rhs>...>&)
583 {
584 return std::bool_constant<hybridTreePath(lhs...) == hybridTreePath(rhs...)>{};
585 }
586
587
589 template <class... S, class... T>
590 [[nodiscard]] constexpr auto operator!=(
591 const HybridTreePath<S...>& lhs,
592 const HybridTreePath<T...>& rhs)
593 {
594 return !(lhs == rhs);
595 }
596
598 template <class S, S... lhs, class T, T... rhs>
599 [[nodiscard]] constexpr auto operator!=(
600 const HybridTreePath<std::integral_constant<S,lhs>...>&,
601 const HybridTreePath<std::integral_constant<T,rhs>...>&)
602 {
603 return std::bool_constant<hybridTreePath(lhs...) != hybridTreePath(rhs...)>{};
604 }
605
606
607 inline namespace Literals {
608
610
614 template <char... digits>
615 constexpr auto operator""_tp()
616 {
617 using namespace Dune::Indices::Literals;
618 return hybridTreePath(operator""_ic<digits...>());
619 }
620
621 } // end namespace Literals
622
623
624 template<std::size_t... i>
625 struct TreePathSize<HybridTreePath<index_constant<i>...> >
626 : public index_constant<sizeof...(i)>
627 {};
628
629
630 template<std::size_t k, std::size_t... i>
631 struct TreePathPushBack<HybridTreePath<index_constant<i>...>,k>
632 {
633 typedef HybridTreePath<index_constant<i>...,index_constant<k>> type;
634 };
635
636 template<std::size_t k, std::size_t... i>
637 struct TreePathPushFront<HybridTreePath<index_constant<i>...>,k>
638 {
639 typedef HybridTreePath<index_constant<k>,index_constant<i>...> type;
640 };
641
642 template<std::size_t k>
643 struct TreePathBack<HybridTreePath<index_constant<k>>>
644 : public index_constant<k>
645 {};
646
647 template<std::size_t j, std::size_t k, std::size_t... l>
648 struct TreePathBack<HybridTreePath<index_constant<j>,index_constant<k>,index_constant<l>...>>
649 : public TreePathBack<HybridTreePath<index_constant<k>,index_constant<l>...>>
650 {};
651
652 template<std::size_t k, std::size_t... i>
653 struct TreePathFront<HybridTreePath<index_constant<k>,index_constant<i>...>>
654 : public index_constant<k>
655 {};
656
657 template<std::size_t k, std::size_t... i>
658 struct TreePathPopBack<HybridTreePath<index_constant<k>>,i...>
659 {
660 typedef HybridTreePath<index_constant<i>...> type;
661 };
662
663 template<std::size_t j,
664 std::size_t k,
665 std::size_t... l,
666 std::size_t... i>
667 struct TreePathPopBack<HybridTreePath<index_constant<j>,index_constant<k>,index_constant<l>...>,i...>
668 : public TreePathPopBack<HybridTreePath<index_constant<k>,index_constant<l>...>,i...,j>
669 {};
670
671 template<std::size_t k, std::size_t... i>
672 struct TreePathPopFront<HybridTreePath<index_constant<k>,index_constant<i>...> >
673 {
674 typedef HybridTreePath<index_constant<i>...> type;
675 };
676
677 template<std::size_t... i, std::size_t... k>
678 struct TreePathConcat<HybridTreePath<index_constant<i>...>,HybridTreePath<index_constant<k>...> >
679 {
680 typedef HybridTreePath<index_constant<i>...,index_constant<k>...> type;
681 };
682
683#ifndef DOXYGEN
684
685 namespace impl {
686
687 // end of recursion
688 template<std::size_t i, typename... T>
689 typename std::enable_if<
690 (i == sizeof...(T))
691 >::type
692 print_hybrid_tree_path(std::ostream& os, const HybridTreePath<T...>& tp, index_constant<i> _i)
693 {}
694
695 // print current entry and recurse
696 template<std::size_t i, typename... T>
697 typename std::enable_if<
698 (i < sizeof...(T))
699 >::type
700 print_hybrid_tree_path(std::ostream& os, const HybridTreePath<T...>& tp, index_constant<i> _i)
701 {
702 os << treePathIndex(tp,_i) << " ";
703 print_hybrid_tree_path(os,tp,index_constant<i+1>{});
704 }
705
706 } // namespace impl
707
708#endif // DOXYGEN
709
711 template<typename... T>
712 std::ostream& operator<<(std::ostream& os, const HybridTreePath<T...>& tp)
713 {
714 os << "HybridTreePath< ";
715 impl::print_hybrid_tree_path(os, tp, index_constant<0>{});
716 os << ">";
717 return os;
718 }
719
720 template<std::size_t... i>
721 using StaticTreePath = HybridTreePath<Dune::index_constant<i>...>;
722
724
725 } // namespace TypeTree
726} //namespace Dune
727
728#endif // DUNE_TYPETREE_TREEPATH_HH
Dune::TypeTree::HybridTreePath
A hybrid version of TreePath that supports both compile time and run time indices.
Definition: treepath.hh:155
Dune::TypeTree::HybridTreePath::back
constexpr auto back() const
Get the last index value. Only available in non-empty paths.
Definition: treepath.hh:267
Dune::TypeTree::HybridTreePath::element
constexpr std::size_t element(std::size_t pos) const
Get the index value at position pos.
Definition: treepath.hh:246
Dune::TypeTree::HybridTreePath::HybridTreePath
constexpr HybridTreePath(std::tuple< T... > t)
Constructor from a std::tuple
Definition: treepath.hh:183
Dune::TypeTree::HybridTreePath::HybridTreePath
constexpr HybridTreePath(U... t)
Constructor from arguments.
Definition: treepath.hh:193
Dune::TypeTree::HybridTreePath::HybridTreePath
constexpr HybridTreePath()
Default constructor.
Definition: treepath.hh:170
Dune::TypeTree::HybridTreePath::element
constexpr auto element(Dune::index_constant< i > pos={}) const
Get the last index value.
Definition: treepath.hh:240
Dune::TypeTree::HybridTreePath::size
static constexpr std::size_t size()
Get the size (length) of this path.
Definition: treepath.hh:207
Dune::TypeTree::HybridTreePath::operator[]
constexpr auto operator[](Dune::index_constant< i >) const
Get the index value at position pos.
Definition: treepath.hh:221
Dune::TypeTree::HybridTreePath::front
constexpr auto front() const
Get the first index value. Only available in non-empty paths.
Definition: treepath.hh:259
Dune::TypeTree::HybridTreePath::enumerate
static constexpr index_sequence enumerate()
Returns an index_sequence for enumerating the components of this HybridTreePath.
Definition: treepath.hh:201
Dune::TypeTree::HybridTreePath::operator[]
constexpr std::size_t operator[](std::size_t pos) const
Get the index value at position pos.
Definition: treepath.hh:227
Dune::TypeTree::HybridTreePath::max_size
static constexpr std::size_t max_size()
Get the size (length) of this path.
Definition: treepath.hh:213
Dune::TypeTree::HybridTreePath::index_sequence
std::index_sequence_for< T... > index_sequence
An index_sequence for the entries in this HybridTreePath.
Definition: treepath.hh:167
documentation.hh
Documentation related stuff.
typetraits.hh
Traits for type conversions and type information.
Dune::unpackIntegerSequence
decltype(auto) constexpr unpackIntegerSequence(F &&f, std::integer_sequence< I, i... > sequence)
Unpack an std::integer_sequence<I,i...> to std::integral_constant<I,i>...
Definition: indices.hh:124
Dune::index_constant
std::integral_constant< std::size_t, i > index_constant
An index constant with value i.
Definition: indices.hh:29
Dune::Hybrid::forEach
constexpr void forEach(Range &&range, F &&f)
Range based for loop.
Definition: hybridutilities.hh:257
Dune::Hybrid::plus
constexpr auto plus
Function object for performing addition.
Definition: hybridutilities.hh:529
Dune::operator==
constexpr EnableIfInterOperable< T1, T2, bool >::type operator==(const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
Checks for equality.
Definition: iteratorfacades.hh:238
Dune::operator!=
constexpr EnableIfInterOperable< T1, T2, bool >::type operator!=(const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
Checks for inequality.
Definition: iteratorfacades.hh:260
Dune::TypeTree::treePathSize
constexpr std::size_t treePathSize(const HybridTreePath< T... > &)
Returns the size (number of components) of the given HybridTreePath.
Definition: treepath.hh:331
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:502
Dune::TypeTree::pop_front
constexpr auto pop_front(const HybridTreePath< T... > &tp)
Removes first index on a HybridTreePath.
Definition: treepath.hh:527
Dune::TypeTree::reverse
constexpr auto reverse(const HybridTreePath< T... > &tp)
Reverses the order of the elements in the path.
Definition: treepath.hh:515
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:483
Dune::TypeTree::join
constexpr auto join(const HybridTreePath< Head... > &head, const Other &... tail)
Join two tree paths into one.
Definition: treepath.hh:509
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:354
Dune::TypeTree::pop_back
constexpr auto pop_back(const HybridTreePath< T... > &tp)
Removes last index on a HybridTreePath.
Definition: treepath.hh:539
Dune::TypeTree::hybridTreePath
constexpr auto hybridTreePath(const T &... t)
Constructs a new HybridTreePath from the given indices.
Definition: treepath.hh:309
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:377
Dune::TypeTree::makeTreePath
constexpr auto makeTreePath(const T... t)
helper function to construct a new HybridTreePath from the given indices.
Definition: treepath.hh:292
Dune::TypeTree::treePath
constexpr auto treePath(const T &... t)
Constructs a new HybridTreePath from the given indices.
Definition: treepath.hh:323
Dune
Dune namespace.
Definition: alignedallocator.hh:13
Dune::push_back
constexpr std::integer_sequence< T, II..., T(IN)> push_back(std::integer_sequence< T, II... >, std::integral_constant< T, IN >={})
Append an index IN to the back of the sequence.
Definition: integersequence.hh:69
Dune::size
constexpr std::integral_constant< std::size_t, sizeof...(II)> size(std::integer_sequence< T, II... >)
Return the size of the sequence.
Definition: integersequence.hh:75
Dune::push_front
constexpr std::integer_sequence< T, T(I0), II... > push_front(std::integer_sequence< T, II... >, std::integral_constant< T, I0 >={})
Append an index I0 to the front of the sequence.
Definition: integersequence.hh:64
Dune::front
constexpr std::integral_constant< T, I0 > front(std::integer_sequence< T, I0, II... >)
Return the first entry of the sequence.
Definition: integersequence.hh:39
Dune::tail
constexpr std::integer_sequence< T, II... > tail(std::integer_sequence< T, I0, II... >)
For a sequence [head,tail...) return the tail sequence.
Definition: integersequence.hh:58
Dune::back
constexpr auto back(std::integer_sequence< T, II... > seq)
Return the last entry of the sequence.
Definition: integersequence.hh:44
Dune::head
constexpr std::integral_constant< T, I0 > head(std::integer_sequence< T, I0, II... >)
For a sequence [head,tail...) return the single head element.
Definition: integersequence.hh:53
std
STL namespace.
Dune::IsInteroperable
Checks whether two types are interoperable.
Definition: typetraits.hh:65
Dune::MetaType
A type that refers to another type.
Definition: typelist.hh:33
version.hh
Various macros to work with Dune module version numbers.
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden & Uni Heidelberg  |  generated with Hugo v0.111.3 (Apr 2, 23:03, 2025)