│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
7#ifndef DUNE_FUNCTIONS_FUNCTIONSPACEBASES_ISTLVECTORBACKEND_HH
│ │ │ │ -
8#define DUNE_FUNCTIONS_FUNCTIONSPACEBASES_ISTLVECTORBACKEND_HH
│ │ │ │ +
7#ifndef DUNE_FUNCTIONS_COMMON_INDEX_ACCESS_HH
│ │ │ │ +
8#define DUNE_FUNCTIONS_COMMON_INDEX_ACCESS_HH
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
14#include <dune/common/std/type_traits.hh>
│ │ │ │ -
15#include <dune/common/indices.hh>
│ │ │ │ +
14#include <dune/common/typetraits.hh>
│ │ │ │ +
15#include <dune/common/concept.hh>
│ │ │ │
16#include <dune/common/hybridutilities.hh>
│ │ │ │ -
17#include <dune/common/concept.hh>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
29 std::enable_if_t<not Dune::models<Imp::Concept::HasStaticIndexAccess, V>() ,
int> = 0>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
36 std::enable_if_t<Dune::models<Imp::Concept::HasStaticIndexAccess, V>(),
int> = 0>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
39 if constexpr (Dune::models<Imp::Concept::HasDynamicIndexAccess<std::size_t>, V>())
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
43 auto indexRange =
typename decltype(range(Hybrid::size(v)))::integer_sequence();
│ │ │ │ -
44 return unpackIntegerSequence([&](
auto... i) {
│ │ │ │ -
45 return uniqueTypeList(std::tuple_cat(
fieldTypes(v[i])...));
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
30template<
class size_type>
│ │ │ │ +
31struct HasDynamicIndexAccess
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
34 auto require(C&& c) ->
decltype(
│ │ │ │ +
35 c[std::declval<size_type>()]
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
39struct HasStaticIndexAccess
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
42 auto require(C&& c) ->
decltype(
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
65template<
class C,
class I,
class F,
│ │ │ │ +
66 std::enable_if_t< Dune::models<Imp::Concept::HasDynamicIndexAccess<I>, C>(),
int> = 0>
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
69 return decltype(Impl::fieldTypes(std::declval<V>())){};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
80 return std::tuple_size_v<std::decay_t<decltype(fieldTypes<V>())>> ==1;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
105class ISTLVectorBackend
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
110 using dynamicIndexAccess_t =
decltype(std::declval<C>()[0]);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
113 using staticIndexAccess_t =
decltype(std::declval<C>()[Dune::Indices::_0]);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
116 using resizeMethod_t =
decltype(std::declval<C>().resize(0));
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
122 using hasDynamicIndexAccess = Dune::Std::is_detected<dynamicIndexAccess_t, std::remove_reference_t<C>>;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
125 using hasStaticIndexAccess = Dune::Std::is_detected<staticIndexAccess_t, std::remove_reference_t<C>>;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
90template<
class C,
class I,
class F,
│ │ │ │ +
91 std::enable_if_t< not Dune::models<Imp::Concept::HasDynamicIndexAccess<I>, C>(),
int> = 0>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
94 using Size =
decltype(Hybrid::size(c));
│ │ │ │ +
95 return Hybrid::switchCases(std::make_index_sequence<Size::value>(), i,
│ │ │ │ +
96 [&](
const auto& ii) ->
decltype(
auto){
│ │ │ │ +
│ │ │ │ +
98 }, [&]() ->
decltype(
auto){
│ │ │ │ +
99 return f(c[Dune::Indices::_0]);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
119 template<
class Index, std::
size_t offset=1>
│ │ │ │ +
120 class ShiftedDynamicMultiIndex
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
123 ShiftedDynamicMultiIndex(
const Index& index) :
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
128 using hasResizeMethod = Dune::Std::is_detected<resizeMethod_t, std::remove_reference_t<C>>;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
131 using isDynamicVector = Dune::Std::is_detected<dynamicIndexAccess_t, std::remove_reference_t<C>>;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
134 using isStaticVector = Dune::Std::bool_constant<
│ │ │ │ -
135 Dune::Std::is_detected_v<staticIndexAccess_t, std::remove_reference_t<C>>
│ │ │ │ -
136 and not Dune::Std::is_detected_v<dynamicIndexAccess_t, std::remove_reference_t<C>>>;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
139 using isScalar = Dune::Std::bool_constant<not Dune::Std::is_detected_v<staticIndexAccess_t, std::remove_reference_t<C>>>;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
142 using isVector = Dune::Std::bool_constant<Dune::Std::is_detected_v<staticIndexAccess_t, std::remove_reference_t<C>>>;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
146 template<
class... Args>
│ │ │ │ -
147 static void forwardToResize(Args&&... args)
│ │ │ │ -
│ │ │ │ -
149 resize(std::forward<Args>(args)...);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
153 template<
class C,
class SizeProvider,
│ │ │ │ -
154 std::enable_if_t<hasResizeMethod<C>::value,
int> = 0>
│ │ │ │ -
155 static void resize(C&& c,
const SizeProvider& sizeProvider,
typename SizeProvider::SizePrefix prefix)
│ │ │ │ -
│ │ │ │ -
157 auto size = sizeProvider.size(prefix);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
170 DUNE_THROW(RangeError,
"The vector entry v[" << prefix <<
"] should refer to a "
│ │ │ │ -
171 <<
"scalar coefficient, but is a dynamically sized vector of size==0");
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
180 for(std::size_t i=0; i<size; ++i)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
183 resize(c[i], sizeProvider, prefix);
│ │ │ │ +
127 std::size_t operator[](std::size_t position)
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
130 return index_[position+offset];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
138 ShiftedDynamicMultiIndex<Index, offset+1> pop()
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
143 std::size_t size()
const
│ │ │ │ +
│ │ │ │ +
145 if (offset < index_.size())
│ │ │ │ +
146 return index_.size() - offset;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
151 const Index& originalIndex()
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
160 template<
class Index, std::
size_t offset=1>
│ │ │ │ +
161 class ShiftedStaticMultiIndex
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
164 ShiftedStaticMultiIndex(
const Index& index) :
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
168 template<std::
size_t i>
│ │ │ │ +
169 auto operator[](Dune::index_constant<i>)
const
│ │ │ │ +
│ │ │ │ +
171 if constexpr (i<size()) {
│ │ │ │ +
172 return index_[Dune::index_constant<i+offset>{}];
│ │ │ │ +
│ │ │ │ +
174 return Dune::index_constant<0>{};
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
181 ShiftedStaticMultiIndex<Index, offset+1> pop()
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
187 template<
class C,
class SizeProvider,
│ │ │ │ -
188 std::enable_if_t<not hasResizeMethod<C>::value,
int> = 0,
│ │ │ │ -
189 std::enable_if_t<isVector<C>::value,
int> = 0>
│ │ │ │ -
190 static void resize(C&& c,
const SizeProvider& sizeProvider,
typename SizeProvider::SizePrefix prefix)
│ │ │ │ -
│ │ │ │ -
192 auto size = sizeProvider.size(prefix);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
186 static constexpr std::size_t size()
│ │ │ │ +
│ │ │ │ +
188 auto fullSize =
decltype(Hybrid::size(std::declval<Index>()))::value;
│ │ │ │ +
189 if (offset < fullSize)
│ │ │ │ +
190 return fullSize - offset;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
207 if (c.size() != size)
│ │ │ │ -
208 DUNE_THROW(RangeError,
"Can't resize non-resizable entry v[" << prefix <<
"] of size " << c.size() <<
" to size(" << prefix <<
")=" << size);
│ │ │ │ +
204 template<std::
size_t offset,
class Index>
│ │ │ │ +
205 ShiftedDynamicMultiIndex<Index, offset> shiftedDynamicMultiIndex(
const Index& index)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
211 using namespace Dune::Hybrid;
│ │ │ │ -
│ │ │ │ -
213 forEach(integralRange(Hybrid::size(c)), [&](
auto&& i) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
221 ISTLVectorBackend<V>::forwardToResize(c[i], sizeProvider, prefix);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
225 template<
class C,
class SizeProvider,
│ │ │ │ -
226 std::enable_if_t<not hasResizeMethod<C>::value,
int> = 0,
│ │ │ │ -
227 std::enable_if_t<isScalar<C>::value,
int> = 0>
│ │ │ │ -
228 static void resize(C&&,
const SizeProvider& sizeProvider,
typename SizeProvider::SizePrefix prefix)
│ │ │ │ -
│ │ │ │ -
230 auto size = sizeProvider.size(prefix);
│ │ │ │ -
│ │ │ │ -
232 DUNE_THROW(RangeError,
"Can't resize scalar vector entry v[" << prefix <<
"] to size(" << prefix <<
")=" << size);
│ │ │ │ -
│ │ │ │ +
218 template<std::
size_t offset,
class Index, std::
size_t oldOffset>
│ │ │ │ +
219 ShiftedDynamicMultiIndex<Index, offset+oldOffset> shiftedDynamicMultiIndex(
const ShiftedDynamicMultiIndex<Index, oldOffset>& index)
│ │ │ │ +
│ │ │ │ +
221 return {index.originalIndex()};
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
224 template<std::
size_t offset,
class Index>
│ │ │ │ +
225 ShiftedStaticMultiIndex<Index, offset> shiftedStaticMultiIndex(
const Index& index)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
235 template<
class C,
class T,
│ │ │ │ -
236 std::enable_if_t<std::is_assignable_v<C&,T>,
int> = 0>
│ │ │ │ -
237 void recursiveAssign(C& c,
const T& t)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
242 template<
class C,
class T,
│ │ │ │ -
243 std::enable_if_t<not std::is_assignable_v<C&,T>,
int> = 0>
│ │ │ │ -
244 void recursiveAssign(C& c,
const T& t)
│ │ │ │ -
│ │ │ │ -
246 Dune::Hybrid::forEach(c, [&](
auto&& ci) {
│ │ │ │ -
247 recursiveAssign(ci, t);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
237template<
class Result,
class Index>
│ │ │ │ +
238struct MultiIndexResolver
│ │ │ │ +
│ │ │ │ +
240 MultiIndexResolver(
const Index& index) :
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
245 std::enable_if_t<not std::is_convertible_v<C&, Result>,
int> = 0>
│ │ │ │ +
246 Result operator()(C&& c)
│ │ │ │ +
│ │ │ │ +
248 auto&& subIndex = Imp::shiftedDynamicMultiIndex<1>(index_);
│ │ │ │ +
249 auto&& subIndexResolver = MultiIndexResolver<Result, decltype(subIndex)>(subIndex);
│ │ │ │ +
250 return (Result)(
hybridIndexAccess(c, index_[Dune::Indices::_0], subIndexResolver));
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
255 ISTLVectorBackend(Vector& vector) :
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
259 template<
class SizeProv
ider>
│ │ │ │ -
260 void resize(
const SizeProvider& sizeProvider)
│ │ │ │ -
│ │ │ │ -
262 auto prefix =
typename SizeProvider::SizePrefix();
│ │ │ │ -
│ │ │ │ -
264 resize(*vector_, sizeProvider, prefix);
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
254 std::enable_if_t<std::is_convertible_v<C&, Result>,
int> = 0>
│ │ │ │ +
255 Result operator()(C&& c)
│ │ │ │ +
│ │ │ │ +
257 return (Result)(std::forward<C>(c));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
267 template<
class MultiIndex>
│ │ │ │ -
268 decltype(
auto)
operator[](
const MultiIndex& index)
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
273 template<
class MultiIndex>
│ │ │ │ -
274 decltype(
auto)
operator[](
const MultiIndex& index)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
288 void operator= (
const T& other)
│ │ │ │ -
│ │ │ │ -
290 recursiveAssign(vector(), other);
│ │ │ │ -
│ │ │ │ +
285template<
class Result,
class C,
class MultiIndex>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
289 Imp::MultiIndexResolver<Result, MultiIndex> multiIndexResolver(index);
│ │ │ │ +
290 return multiIndexResolver(c);
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
294 void operator= (
const ISTLVectorBackend<T>& other)
│ │ │ │ -
│ │ │ │ -
296 vector() = other.vector();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
299 const Vector& vector()
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
300 template<
class C,
class MultiIndex,
class IsFinal>
│ │ │ │ +
301 constexpr decltype(
auto) resolveDynamicMultiIndex(C&& c,
const MultiIndex& multiIndex,
const IsFinal& isFinal)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
305 return Hybrid::ifElse(isFinal(c), [&, c =
forwardCapture(std::forward<C>(c))](
auto) ->
decltype(
auto) {
│ │ │ │ +
306 assert(multiIndex.size() == 0);
│ │ │ │ +
│ │ │ │ +
308 }, [&](
auto) ->
decltype(
auto) {
│ │ │ │ +
309 auto hasDynamicAccess =
callableCheck([](
auto&& cc) -> std::void_t<
decltype(cc[0])> {});
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
349template<
class Vector>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
352 static_assert(hasUniqueFieldType<Vector&>(),
"Vector type passed to istlVectorBackend() does not have a unique field type.");
│ │ │ │ -
353 return Impl::ISTLVectorBackend<Vector>(v);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
387template<
class Vector>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
390 static_assert(hasUniqueFieldType<const Vector&>(),
"Vector type passed to istlVectorBackend() does not have a unique field type.");
│ │ │ │ -
391 return Impl::ISTLVectorBackend<const Vector>(v);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
auto istlVectorBackend(Vector &v)
Return a vector backend wrapping non-const ISTL like containers.
Definition istlvectorbackend.hh:350
│ │ │ │ +
│ │ │ │ +
312 auto i = multiIndex[0];
│ │ │ │ +
313 auto tail = multiIndex.pop();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
320 return Hybrid::ifElse(hasDynamicAccess(c), [&](
auto id) ->
decltype(
auto) {
│ │ │ │ +
321 return Imp::resolveDynamicMultiIndex(
id(c)[i], tail, isFinal);
│ │ │ │ +
322 }, [&](
auto id) ->
decltype(
auto) {
│ │ │ │ +
│ │ │ │ +
324 auto indexRange =
typename decltype(range(Hybrid::size(
id(c))))::integer_sequence();
│ │ │ │ +
325 return Hybrid::switchCases(indexRange, i, [&](
auto static_i) ->
decltype(
auto){
│ │ │ │ +
│ │ │ │ +
327 return Imp::resolveDynamicMultiIndex(
id(c)[static_i], tail, isFinal);
│ │ │ │ +
328 }, [&]() ->
decltype(
auto){
│ │ │ │ +
│ │ │ │ +
330 return Imp::resolveDynamicMultiIndex(
id(c)[Dune::Indices::_0], tail, isFinal);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
336 template<
class C,
class MultiIndex>
│ │ │ │ +
337 constexpr decltype(
auto) resolveStaticMultiIndex(C&& c,
const MultiIndex& multiIndex)
│ │ │ │ +
│ │ │ │ +
339 auto isExhausted = Hybrid::equal_to(Hybrid::size(multiIndex), Dune::Indices::_0);
│ │ │ │ +
340 return Hybrid::ifElse(isExhausted, [&, c =
forwardCapture(std::forward<C>(c))](
auto) ->
decltype(
auto) {
│ │ │ │ +
│ │ │ │ +
342 }, [&](
auto id) ->
decltype(
auto) {
│ │ │ │ +
343 auto head = multiIndex[Dune::Indices::_0];
│ │ │ │ +
344 auto tail = multiIndex.pop();
│ │ │ │ +
│ │ │ │ +
346 return Imp::resolveStaticMultiIndex(
id(c)[head], tail);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
376template<
class C,
class MultiIndex,
class IsFinal>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
379 return Imp::resolveDynamicMultiIndex(std::forward<C>(c), Imp::shiftedDynamicMultiIndex<0>(multiIndex), isFinal);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
398template<
class C,
class MultiIndex>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
402 return Imp::resolveDynamicMultiIndex(std::forward<C>(c), Imp::shiftedDynamicMultiIndex<0>(multiIndex), hasNoIndexAccess);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
420template<
class C,
class MultiIndex>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
423 return Imp::resolveStaticMultiIndex(std::forward<C>(c), Imp::shiftedStaticMultiIndex<0>(multiIndex));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
auto hybridIndexAccess(C &&c, const I &i, F &&f) -> decltype(f(c[i]))
Provide operator[] index-access for containers.
Definition indexaccess.hh:67
│ │ │ │ +
constexpr decltype(auto) resolveStaticMultiIndex(C &&c, const MultiIndex &multiIndex)
Provide multi-index access by chaining operator[].
Definition indexaccess.hh:421
│ │ │ │ +
auto callableCheck(Expression f)
Create a predicate for checking validity of expressions.
Definition utility.hh:283
│ │ │ │
constexpr decltype(auto) resolveDynamicMultiIndex(C &&c, const MultiIndex &multiIndex, const IsFinal &isFinal)
Provide multi-index access by chaining operator[].
Definition indexaccess.hh:377
│ │ │ │ +
Result hybridMultiIndexAccess(C &&c, const MultiIndex &index)
Provide multi-index access by chaining operator[].
Definition indexaccess.hh:286
│ │ │ │ +
auto negatePredicate(Check check)
Negate given predicate.
Definition utility.hh:308
│ │ │ │
Definition polynomial.hh:17
│ │ │ │ -
constexpr auto fieldTypes()
Generate list of field types in container.
Definition istlvectorbackend.hh:67
│ │ │ │ -
constexpr bool hasUniqueFieldType()
Check if container has a unique field type.
Definition istlvectorbackend.hh:78
│ │ │ │ -
std::vector< Child > Vector
Descriptor for vectors with all children of the same type and dynamic size.
Definition containerdescriptors.hh:124
│ │ │ │ -
│ │ │ │ +
auto forwardCapture(T &&t)
Create a capture object for perfect forwarding.
Definition utility.hh:376
│ │ │ │
