1#ifndef __DUNE_ACFEM_MPL_CONDITIONALJOIN_HH__
2#define __DUNE_ACFEM_MPL_CONDITIONALJOIN_HH__
10 namespace TupleUtilities {
27 template<
template<
class...>
class F,
class Tuple,
class E,
28 std::enable_if_t<(IsTupleLike<Tuple>::value
29 && PredicateMatch<Tuple, PredicateProxy<F, E>::template ForwardFirst>::value
33 return std::tuple_cat(std::forward<Tuple>(t), std::tuple<E>(e));
37 template<
template<
class...>
class F,
class Tuple,
class E,
38 std::enable_if_t<(IsTupleLike<Tuple>::value
39 && !PredicateMatch<Tuple, PredicateProxy<F, E>::template ForwardFirst>::value
41 constexpr auto pushBackIf(Tuple&& t, E&& e, PredicateWrapper<F> = PredicateWrapper<F>{})
43 return std::forward<Tuple>(t);
51 template<
template<
class...>
class F,
class Tuple,
class E,
52 std::enable_if_t<(IsTupleLike<Tuple>::value
53 && !PredicateMatch<Tuple, PredicateProxy<F, E>::template ForwardFirst>::value
57 return std::tuple_cat(std::forward<Tuple>(t), std::tuple<E>(e));
61 template<
template<
class...>
class F,
class Tuple,
class E,
62 std::enable_if_t<(IsTupleLike<Tuple>::value
63 && PredicateMatch<Tuple, PredicateProxy<F, E>::template ForwardFirst>::value
65 constexpr auto pushBackUnless(Tuple&& t, E&& e, PredicateWrapper<F> = PredicateWrapper<F>{})
67 return std::forward<Tuple>(t);
73 template<
template<
class...>
class F,
class Tuple,
class E,
74 std::enable_if_t<(IsTupleLike<Tuple>::value
75 && PredicateMatch<Tuple, PredicateProxy<F, E>::template ForwardFirst>::value
79 return std::tuple_cat(std::tuple<E>(e), std::forward<Tuple>(t));
83 template<
template<
class...>
class F,
class Tuple,
class E,
84 std::enable_if_t<(IsTupleLike<Tuple>::value
85 && !PredicateMatch<Tuple, PredicateProxy<F, E>::template ForwardFirst>::value
87 constexpr auto addFrontIf(Tuple&& t, E&& e, PredicateWrapper<F> = PredicateWrapper<F>{})
89 return std::forward<Tuple>(t);
95 template<
template<
class...>
class F,
class Tuple,
class E,
96 std::enable_if_t<(IsTupleLike<Tuple>::value
97 && !PredicateMatch<Tuple, PredicateProxy<F, E>::template ForwardFirst>::value
101 return std::tuple_cat(std::tuple<E>(e), std::forward<Tuple>(t));
105 template<
template<
class...>
class F,
class Tuple,
class E,
106 std::enable_if_t<(IsTupleLike<Tuple>::value
107 && PredicateMatch<Tuple, PredicateProxy<F, E>::template ForwardFirst>::value
109 constexpr auto addFrontUnless(Tuple&& t, E&& e, PredicateWrapper<F> = PredicateWrapper<F>{})
111 return std::forward<Tuple>(t);
115 template<std::size_t N,
template<
class...>
class F,
class T1,
class T2,
116 std::enable_if_t<(N >= size<T2>()),
int> = 0>
117 constexpr T1 joinIfHelper(T1&& t1, T2&& t2, IndexConstant<N> = IndexConstant<N>{})
122 template<std::size_t N,
template<
class,
class,
class...>
class F,
class T1,
class T2,
123 std::enable_if_t<(N < size<T2>()),
int> = 0>
124 constexpr auto joinIfHelper(T1&& t1, T2&& t2, IndexConstant<N> = IndexConstant<N>{})
126 return joinIfHelper<N+1, F>(pushBackIf<F>(std::forward<T1>(t1), get<N>(std::forward<T2>(t2))),
127 std::forward<T2>(t2));
130 template<std::size_t N,
template<
class...>
class F,
class T1,
class T2,
131 std::enable_if_t<(N >= size<T2>()),
int> = 0>
132 constexpr T1 joinUnlessHelper(T1&& t1, T2&& t2, IndexConstant<N> = IndexConstant<N>{})
134 return std::forward<T1>(t1);
137 template<std::size_t N,
template<
class...>
class F,
class T1,
class T2,
138 std::enable_if_t<(N < size<T2>()),
int> = 0>
139 constexpr auto joinUnlessHelper(T1&& t1, T2&& t2, IndexConstant<N> = IndexConstant<N>{})
141 return joinUnlessHelper<N+1, F>(pushBackUnless<F>(std::forward<T1>(t1), get<N>(std::forward<T2>(t2))),
142 std::forward<T2>(t2));
148 template<
template<
class...>
class F,
class T,
class... Arg,
149 std::enable_if_t<(!IsAlwaysTrue<F>::value
150 && IsTupleLike<T>::value
151 &&
sizeof...(Arg) == 1
152 &&
size<
decltype(joinIfHelper<0, F>(std::declval<T>(), std::declval<Arg>()...))>() > size<T>()
154 constexpr auto joinIf(T&& t, Arg&&... arg)
156 return joinIfHelper<0, F>(std::forward<T>(t), std::forward<Arg>(arg)...);
162 template<
template<
class...>
class F,
class T,
class... Arg,
165 &&
sizeof...(Arg) == 1
166 &&
size<
decltype(joinIfHelper<0, F>(std::declval<T>(), std::declval<Arg>()...))>() == size<T>()
170 return std::forward<T>(t);
173 template<
template<
class...>
class F,
class T0,
class T1,
class... Arg,
177 &&
sizeof...(Arg) >= 1),
int> = 0>
178 constexpr auto joinIf(T0&& t0, T1&& t1, Arg&&... arg)
180 return joinIf<F>(joinIf<F>(std::forward<T0>(t0), std::forward<T1>(t1)), std::forward<Arg>(arg)...);
183 template<
template<
class...>
class F,
class T,
class... Arg,
184 std::enable_if_t<(IsAlwaysTrue<F>::value
185 && IsTupleLike<T>::value
187 constexpr auto joinIf(T&& t, Arg&&... arg)
189 return std::tuple_cat(std::forward<T>(t), std::forward<Arg>(arg)...);
195 template<
template<
class...>
class F,
class T,
class... Arg,
196 std::enable_if_t<(!IsAlwaysFalse<F>::value
197 && IsTupleLike<T>::value
198 &&
sizeof...(Arg) == 1
199 &&
size<
decltype(joinUnlessHelper<0, F>(std::declval<T>(), std::declval<Arg>()...))>() > size<T>()
203 return joinUnlessHelper<0, F>(std::forward<T>(t), std::forward<Arg>(arg)...);
209 template<
template<
class...>
class F,
class T,
class... Arg,
212 &&
sizeof...(Arg) == 1
213 &&
size<
decltype(joinUnlessHelper<0, F>(std::declval<T>(), std::declval<Arg>()...))>() == size<T>()
217 return std::forward<T>(t);
220 template<
template<
class...>
class F,
class T0,
class T1,
class... Arg,
224 &&
sizeof...(Arg) >= 1),
int> = 0>
225 constexpr auto joinUnless(T0&& t0, T1&& t1, Arg&&... arg)
227 return joinUnless<F>(joinUnless<F>(std::forward<T0>(t0), std::forward<T1>(t1)), std::forward<Arg>(arg)...);
230 template<
template<
class...>
class F,
class T,
class... Arg,
231 std::enable_if_t<(IsAlwaysFalse<F>::value
232 && IsTupleLike<T>::value
234 constexpr auto joinUnless(T&& t, Arg&&... arg)
236 return std::tuple_cat(std::forward<T>(t), std::forward<Arg>(arg)...);
constexpr std::size_t size()
Gives the number of elements in tuple-likes and std::integer_sequence.
Definition: size.hh:73
constexpr auto addFrontIf(Tuple &&t, E &&e, PredicateWrapper< F >=PredicateWrapper< F >{})
Enforce kind of uniqueness.
Definition: conditionaljoin.hh:77
constexpr auto pushBackIf(Tuple &&t, E &&e, PredicateWrapper< F >=PredicateWrapper< F >{})
Enforce kind of uniqueness.
Definition: conditionaljoin.hh:31
constexpr auto joinIf(T &&t, Arg &&... arg)
Add the elements of Arg... in turn to T if the predicate F matches.
Definition: conditionaljoin.hh:154
constexpr auto joinUnless(T &&t, Arg &&... arg)
Add the elements of Arg... in turn to T if the predicate F matches.
Definition: conditionaljoin.hh:201
constexpr auto pushBackUnless(Tuple &&t, E &&e, PredicateWrapper< F >=PredicateWrapper< F >{})
Enforce kind of uniqueness.
Definition: conditionaljoin.hh:55
constexpr auto addFrontUnless(Tuple &&t, E &&e, PredicateWrapper< F >=PredicateWrapper< F >{})
Enforce kind of uniqueness.
Definition: conditionaljoin.hh:99
Assume a predicate is a traits-class and would never evaluate to false unless it is equivalent to Alw...
Definition: types.hh:183
Assume a predicate is a traits-class and would never evaluate to true unless it is equivalent to Alwa...
Definition: types.hh:167
Wrap a predicate into a class which can be passed on as argument.
Definition: types.hh:264