45template <
bool,
typename T>
46struct filter_if_false_result;
51struct filter_if_false_result<
true, T>
53 using type = std::tuple<T>;
54 template <
template <
typename...>
class Op>
55 using operation_type = Op<T>;
61struct filter_if_false_result<
false, T>
63 using type = std::tuple<>;
64 template <
template <
typename...>
class Op>
65 using operation_type = std::tuple<>;
74template <
bool,
typename T>
75struct filter_if_true_result;
78struct filter_if_true_result<
false, T>
80 using type = std::tuple<T>;
81 template <
template <
typename...>
class Op>
82 using operation_type = Op<T>;
88struct filter_if_true_result<
true, T>
90 using type = std::tuple<>;
91 template <
template <
typename...>
class Op>
92 using operation_type = std::tuple<>;
101template <
template <
typename>
class Predicate,
typename Sequence>
102struct filter_if_false;
106template <
template <
typename>
class Predicate,
typename... Ts>
107struct filter_if_false<Predicate,
std::tuple<Ts...>>
110 conditional_t<Predicate<Ts>::value, std::tuple<Ts>, std::tuple<>>...>;
115template <
template <
typename>
class Predicate,
typename... Ts>
116struct filter_if_false<Predicate,
type_list<Ts...>>
118 using type = convert_t<tuple_concat_t<conditional_t<Predicate<Ts>::value,
119 std::tuple<Ts>, std::tuple<>>...>,
125template <
template <
typename>
class Predicate,
typename... Ts>
126struct filter_if_false<Predicate, component_list<Ts...>>
128 using type = convert_t<tuple_concat_t<conditional_t<Predicate<Ts>::value,
129 std::tuple<Ts>, std::tuple<>>...>,
135template <
template <
typename>
class Predicate,
typename... Ts>
136struct filter_if_false<Predicate, component_tuple<Ts...>>
138 using type = convert_t<tuple_concat_t<conditional_t<Predicate<Ts>::value,
139 std::tuple<Ts>, std::tuple<>>...>,
145template <
template <
typename>
class Predicate,
typename... Ts>
146struct filter_if_false<Predicate, auto_list<Ts...>>
148 using type = convert_t<tuple_concat_t<conditional_t<Predicate<Ts>::value,
149 std::tuple<Ts>, std::tuple<>>...>,
155template <
template <
typename>
class Predicate,
typename... Ts>
156struct filter_if_false<Predicate, auto_tuple<Ts...>>
158 using type = convert_t<tuple_concat_t<conditional_t<Predicate<Ts>::value,
159 std::tuple<Ts>, std::tuple<>>...>,
165template <
template <
typename>
class Predicate,
typename Sequence>
166using filter_false =
typename filter_if_false<Predicate, Sequence>::type;
176template <
template <
typename>
class Predicate,
typename Sequence>
177struct filter_if_false_after_decay;
181template <
template <
typename>
class Predicate,
typename... Ts>
182struct filter_if_false_after_decay<Predicate,
std::tuple<Ts...>>
185 tuple_concat_t<conditional_t<Predicate<decay_t<remove_pointer_t<Ts>>>::value,
186 std::tuple<Ts>, std::tuple<>>...>;
191template <
template <
typename>
class Predicate,
typename... Ts>
192struct filter_if_false_after_decay<Predicate,
type_list<Ts...>>
195 tuple_concat_t<conditional_t<Predicate<decay_t<remove_pointer_t<Ts>>>::value,
196 std::tuple<Ts>, std::tuple<>>...>,
202template <
template <
typename>
class Predicate,
typename Sequence>
203using filter_false_after_decay_t =
204 typename filter_if_false_after_decay<Predicate, Sequence>::type;
212template <
template <
typename>
class Predicate,
typename... Ts>
216 conditional_t<Predicate<Ts>::value, std::tuple<>, std::tuple<Ts>>...>;
221template <
template <
typename>
class Predicate,
typename... Ts>
222struct filter_if_true<Predicate,
std::tuple<Ts...>>
225 conditional_t<Predicate<Ts>::value, std::tuple<>, std::tuple<Ts>>...>;
230template <
template <
typename>
class Predicate,
typename... Ts>
231struct filter_if_true<Predicate,
type_list<Ts...>>
233 using type = convert_t<tuple_concat_t<conditional_t<Predicate<Ts>::value,
234 std::tuple<>, std::tuple<Ts>>...>,
238template <
template <
typename>
class Predicate,
typename Sequence>
239using filter_true =
typename filter_if_true<Predicate, Sequence>::type;
247template <
template <
typename>
class Predicate,
typename Sequence>
250template <
template <
typename>
class Predicate,
typename Sequence>
256template <
template <
typename>
class Predicate,
typename... Sequence>
259 using type = impl::filter_false<Predicate, std::tuple<Sequence...>>;
262template <
template <
typename>
class Predicate,
typename... Sequence>
265 using type = impl::filter_false<Predicate, std::tuple<Sequence...>>;
268template <
template <
typename>
class Predicate,
typename... Sequence>
275template <
template <
typename>
class Predicate,
typename... Sequence>
281template <
template <
typename>
class Predicate,
typename... Sequence>
284 using type = impl::filter_true<Predicate, std::tuple<Sequence...>>;
287template <
template <
typename>
class Predicate,
typename... Sequence>
290 using type = impl::filter_true<Predicate, std::tuple<Sequence...>>;
293template <
template <
typename>
class Predicate,
typename... Sequence>
300template <
template <
typename>
class Predicate,
typename... Sequence>
316template <
typename... Types>
329template <
typename... T>
332template <
typename... T>
335template <
typename Tag,
typename... T>
339template <
typename... T>
342template <
typename... T>
345template <
typename... T>
348template <
typename... T>
351template <
typename Tag,
typename... T>
354template <
typename... T>
This is a variadic component wrapper where all components are optional at runtime....
This is a variadic component wrapper where all components are allocated on the stack and cannot be di...
This is a variadic component wrapper where all components are optional at runtime....
This is a variadic component wrapper where all components are allocated on the stack and cannot be di...
This is a variadic component wrapper which provides the least amount of runtime and compilation overh...
impl::filter_false< Predicate, std::tuple< Sequence... > > type
impl::filter_true< concepts::is_quirk_type, T > non_quirk_t
impl::filter_false_after_decay_t< trait::is_available, type_list< Types... > > implemented_t
filter out any types that are not available
convert_t< impl::filter_false< Predicate, std::tuple< Sequence... > >, type_list<> > type
impl::filter_false< Predicate, Sequence > filter_false_t
impl::filter_false_after_decay_t< trait::is_available, T > implemented_list_t
typename get_true_types< Predicate, Sequence... >::type get_true_types_t
typename get_false_types< Predicate, Sequence... >::type get_false_types_t
convert_t< impl::filter_true< Predicate, std::tuple< Sequence... > >, type_list<> > type
impl::filter_false< trait::is_available, T > available_t
impl::filter_true< concepts::is_placeholder, T > non_placeholder_t
impl::filter_true< Predicate, Sequence > filter_true_t
impl::filter_true< Predicate, std::tuple< Sequence... > > type
generic alias for extracting all types with a specified trait disabled
generic alias for extracting all types with a specified trait enabled
typename impl::concat< Types... >::type concat
convert_t< mpl::available_t< type_list< T... > >, auto_bundle< Tag > > auto_bundle_t
typename impl::tuple_concat< Ts... >::type tuple_concat_t
convert_t< mpl::available_t< type_list< T... > >, component_bundle< Tag > > component_bundle_t
convert_t< mpl::available_t< concat< T... > >, component_tuple<> > component_tuple_t
convert_t< mpl::available_t< concat< T... > >, auto_tuple<> > auto_tuple_t
convert_t< mpl::available_t< concat< T... > >, auto_list<> > auto_list_t
convert_t< mpl::available_t< concat< T... > >, std::tuple<> > stl_tuple_t
convert_t< mpl::available_t< concat< T... > >, type_list<> > type_list_t
typename impl::convert< T, U >::type convert_t
convert_t< mpl::available_t< concat< T... > >, component_list<> > component_list_t
convert_t< mpl::available_t< concat< T... > >, lightweight_tuple<> > lightweight_tuple_t
lightweight tuple-alternative for meta-programming logic
This is a variadic component wrapper which combines the features of tim::component_tuple<T....
This is a variadic component wrapper which combines the features of tim::auto_tuple<T....
trait that signifies that an implementation for the component is available. When this is set to false...