15 #include <type_traits>
21 COMMS_GNU_WARNING_PUSH
22 COMMS_GNU_WARNING_DISABLE(
"-Wtype-limits")
33 template <
typename TType>
38 static constexpr
bool Value =
false;
42 template <
typename... TArgs>
43 struct IsTuple<std::tuple<TArgs...> >
45 static constexpr
bool Value =
true;
52 template <
typename TType>
63 template <
bool THasElems,
typename...>
64 struct IsInTupleHelper
66 template <
typename TType,
typename TFirst,
typename... TRest>
69 std::is_same<TType, TFirst>::value
72 typename IsInTupleHelper<(
sizeof...(TRest) != 0U)>::template Type<TType, TRest...>
76 template <
typename... TParams>
77 struct IsInTupleHelper<false, TParams...>
79 template <
typename TType,
typename...>
80 using Type = std::false_type;
93 template <
typename TTuple>
98 template <
typename... TTypes>
101 template <
typename TType>
103 typename details::IsInTupleHelper<(
sizeof...(TTypes) != 0U)>::template Type<TType, TTypes...>;
113 template <
bool THasElems,
typename...>
114 class TupleAsAlignedUnionHelper
116 template <
typename TElem>
117 using ElemAlignmentType = std::integral_constant<std::size_t,
alignof(TElem)>;
119 template <
typename TElem>
120 using ElemSizeType = std::integral_constant<std::size_t,
sizeof(TElem)>;
123 template <
typename TElem,
typename... TRest>
124 using AlignmentType =
125 comms::util::IntMaxBinaryOp<>::template Type<
126 ElemAlignmentType<TElem>,
127 typename TupleAsAlignedUnionHelper<(0U <
sizeof...(TRest))>::template AlignmentType<TRest...>
130 template <
typename TElem,
typename... TRest>
132 comms::util::IntMaxBinaryOp<>::template Type<
134 typename TupleAsAlignedUnionHelper<(0U <
sizeof...(TRest))>::template SizeType<TRest...>
138 template <
typename... TParams>
139 class TupleAsAlignedUnionHelper<false, TParams...>
142 template <
typename...>
143 using AlignmentType = std::integral_constant<std::size_t, 0U>;
145 template <
typename...>
146 using SizeType = std::integral_constant<std::size_t, 0U>;
155 template <
typename TTuple>
169 template <
typename... TTypes>
172 using AlignmentType =
173 typename details::TupleAsAlignedUnionHelper<(0U <
sizeof...(TTypes))>::template AlignmentType<TTypes...>;
176 typename details::TupleAsAlignedUnionHelper<(0U <
sizeof...(TTypes))>::template SizeType<TTypes...>;
179 typename std::aligned_storage<
187 template <
typename TTuple>
195 template <
bool THasElems>
196 struct TupleForEachHelper
198 template <std::
size_t TOff, std::
size_t TRem,
typename TTuple,
typename TFunc>
199 static void exec(TTuple&& tuple, TFunc&& func)
201 using Tuple =
typename std::decay<TTuple>::type;
203 static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
204 static constexpr std::size_t OffsetedRem = TRem + TOff;
205 static_assert(OffsetedRem <= TupleSize,
"Incorrect parameters");
207 static constexpr std::size_t Idx = TupleSize - OffsetedRem;
208 static constexpr std::size_t NextRem = TRem - 1;
209 static constexpr
bool HasElemsToProcess = (NextRem != 0U);
210 func(std::get<Idx>(std::forward<TTuple>(tuple)));
211 TupleForEachHelper<HasElemsToProcess>::template exec<TOff, NextRem>(
212 std::forward<TTuple>(tuple),
213 std::forward<TFunc>(func));
218 struct TupleForEachHelper<false>
220 template <std::
size_t TOff, std::
size_t TRem,
typename TTuple,
typename TFunc>
221 static void exec(TTuple&& tuple, TFunc&& func)
223 static_cast<void>(tuple);
224 static_cast<void>(func);
241 template <
typename TTuple,
typename TFunc>
244 using Tuple =
typename std::decay<TTuple>::type;
245 static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
246 static constexpr
bool HasTupleElems = (TupleSize != 0U);
248 details::TupleForEachHelper<HasTupleElems>::template exec<0, TupleSize>(
249 std::forward<TTuple>(tuple),
250 std::forward<TFunc>(func));
262 template <std::
size_t TIdx,
typename TTuple,
typename TFunc>
265 using Tuple =
typename std::decay<TTuple>::type;
266 static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
267 static_assert(TIdx <= TupleSize,
268 "The index is too big.");
270 static constexpr
bool HasTupleElems = (TIdx != 0U);
272 details::TupleForEachHelper<HasTupleElems>::template exec<TupleSize - TIdx, TIdx>(
273 std::forward<TTuple>(tuple),
274 std::forward<TFunc>(func));
285 template <std::
size_t TIdx,
typename TTuple,
typename TFunc>
288 using Tuple =
typename std::decay<TTuple>::type;
289 static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
290 static_assert(TIdx <= TupleSize,
291 "The index is too big.");
292 static constexpr std::size_t RemCount = TupleSize - TIdx;
293 static constexpr
bool HasTupleElems = (RemCount != 0U);
295 details::TupleForEachHelper<HasTupleElems>::template exec<0, RemCount>(
296 std::forward<TTuple>(tuple),
297 std::forward<TFunc>(func));
311 template <std::
size_t TFromIdx, std::
size_t TUntilIdx,
typename TTuple,
typename TFunc>
314 using Tuple =
typename std::decay<TTuple>::type;
315 static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
316 static_assert(TFromIdx <= TupleSize,
317 "The from index is too big.");
319 static_assert(TUntilIdx <= TupleSize,
320 "The until index is too big.");
322 static_assert(TFromIdx <= TUntilIdx,
323 "The from index must be less than until index.");
325 static constexpr std::size_t FieldsCount = TUntilIdx - TFromIdx;
326 static constexpr
bool HasTupleElems = (FieldsCount != 0U);
328 details::TupleForEachHelper<HasTupleElems>::template exec<TupleSize - TUntilIdx, FieldsCount>(
329 std::forward<TTuple>(tuple),
330 std::forward<TFunc>(func));
337 template <
bool THasElems>
338 struct TupleForEachTypeHelper
340 template <std::
size_t TRem,
typename TTuple,
typename TFunc>
341 static void exec(TFunc&& func)
343 using Tuple =
typename std::decay<TTuple>::type;
344 static_assert(IsTuple<Tuple>::Value,
"TTuple must be std::tuple");
345 static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
346 static_assert(TRem <= TupleSize,
"Incorrect TRem");
348 static constexpr std::size_t Idx = TupleSize - TRem;
349 static constexpr std::size_t NextRem = TRem - 1U;
350 static constexpr
bool NextHasElems = (NextRem != 0U);
352 using ElemType =
typename std::tuple_element<Idx, Tuple>::type;
355 func.operator()<ElemType>();
357 func.template operator()<ElemType>();
359 TupleForEachTypeHelper<NextHasElems>::template exec<NextRem, TTuple>(
360 std::forward<TFunc>(func));
365 struct TupleForEachTypeHelper<false>
367 template <std::
size_t TRem,
typename TTuple,
typename TFunc>
368 static void exec(TFunc&& func)
370 static_cast<void>(func);
386 template <
typename TTuple,
typename TFunc>
389 using Tuple =
typename std::decay<TTuple>::type;
390 static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
391 static constexpr
bool HasElems = (TupleSize != 0U);
393 details::TupleForEachTypeHelper<HasElems>::template exec<TupleSize, Tuple>(
394 std::forward<TFunc>(func));
402 template <
bool THasElems>
403 struct TupleForEachWithIdxHelper
405 template <std::
size_t TRem,
typename TTuple,
typename TFunc>
406 static void exec(TTuple&& tuple, TFunc&& func)
408 using Tuple =
typename std::decay<TTuple>::type;
409 static_assert(IsTuple<Tuple>::Value,
"TTuple must be std::tuple");
410 static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
411 static_assert(TRem <= TupleSize,
"Incorrect TRem");
413 static constexpr std::size_t Idx = TupleSize - TRem;
414 static constexpr std::size_t NextRem = TRem - 1;
415 static constexpr
bool NextHasElems = (NextRem != 0U);
417 func(std::get<Idx>(std::forward<TTuple>(tuple)), Idx);
418 TupleForEachWithIdxHelper<NextHasElems>::template exec<NextRem>(
419 std::forward<TTuple>(tuple),
420 std::forward<TFunc>(func));
425 struct TupleForEachWithIdxHelper<false>
427 template <std::
size_t TRem,
typename TTuple,
typename TFunc>
428 static void exec(TTuple&& tuple, TFunc&& func)
430 static_cast<void>(tuple);
431 static_cast<void>(func);
451 template <
typename TTuple,
typename TFunc>
454 using Tuple =
typename std::decay<TTuple>::type;
455 static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
456 static constexpr
bool HasElems = (TupleSize != 0U);
458 details::TupleForEachWithIdxHelper<HasElems>::template exec<TupleSize>(
459 std::forward<TTuple>(tuple),
460 std::forward<TFunc>(func));
466 template <
bool THasElems>
467 struct TupleForEachWithTemplateParamIdxHelper
469 template <std::
size_t TRem,
typename TTuple,
typename TFunc>
470 static void exec(TTuple&& tuple, TFunc&& func)
472 using Tuple =
typename std::decay<TTuple>::type;
473 static_assert(IsTuple<Tuple>::Value,
"TTuple must be std::tuple");
474 static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
475 static_assert(TRem <= TupleSize,
"Incorrect TRem");
477 static constexpr std::size_t Idx = TupleSize - TRem;
478 static constexpr std::size_t NextRem = TRem - 1;
479 static constexpr
bool NextHasElems = (NextRem != 0U);
483 func.operator()<Idx>(std::get<Idx>(std::forward<TTuple>(tuple)));
485 func.template operator()<Idx>(std::get<Idx>(std::forward<TTuple>(tuple)));
487 TupleForEachWithTemplateParamIdxHelper<NextHasElems>::template exec<NextRem>(
488 std::forward<TTuple>(tuple),
489 std::forward<TFunc>(func));
494 struct TupleForEachWithTemplateParamIdxHelper<false>
496 template <std::
size_t TRem,
typename TTuple,
typename TFunc>
497 static void exec(TTuple&& tuple, TFunc&& func)
499 static_cast<void>(tuple);
500 static_cast<void>(func);
522 template <
typename TTuple,
typename TFunc>
525 using Tuple =
typename std::decay<TTuple>::type;
526 static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
527 static constexpr
bool HasElems = (TupleSize != 0U);
529 details::TupleForEachWithTemplateParamIdxHelper<HasElems>::template exec<TupleSize>(
530 std::forward<TTuple>(tuple),
531 std::forward<TFunc>(func));
540 template <
bool THasElems>
541 struct TupleAccumulateHelper
543 template <std::
size_t TOff, std::
size_t TRem,
typename TTuple,
typename TValue,
typename TFunc>
544 static constexpr TValue exec(TTuple&& tuple,
const TValue& value, TFunc&& func)
546 using Tuple =
typename std::decay<TTuple>::type;
547 static_assert(IsTuple<Tuple>::Value,
"TTuple must be std::tuple");
548 static_assert((TOff + TRem) <= std::tuple_size<Tuple>::value,
"Incorrect params");
551 TupleAccumulateHelper<(1U < TRem)>::
template exec<TOff + 1, TRem - 1U>(
552 std::forward<TTuple>(tuple),
553 func(value, std::get<TOff>(std::forward<TTuple>(tuple))),
554 std::forward<TFunc>(func));
559 struct TupleAccumulateHelper<false>
561 template <std::
size_t TOff, std::
size_t TRem,
typename TTuple,
typename TValue,
typename TFunc>
562 static constexpr TValue exec(TTuple&& ,
const TValue& value, TFunc&& )
588 template <
typename TTuple,
typename TValue,
typename TFunc>
591 using Tuple =
typename std::decay<TTuple>::type;
593 return details::TupleAccumulateHelper<std::tuple_size<Tuple>::value != 0>::template exec<0, std::tuple_size<Tuple>::value>(
594 std::forward<TTuple>(tuple),
596 std::forward<TFunc>(func));
616 template <std::
size_t TFrom, std::
size_t TUntil,
typename TTuple,
typename TValue,
typename TFunc>
619 using Tuple =
typename std::decay<TTuple>::type;
621 static_assert(TFrom <= TUntil,
"TFrom mustn't be greater that TUntil");
622 static_assert(TUntil <= std::tuple_size<Tuple>::value,
"TUntil mustn't exceed size of the tuple");
624 return details::TupleAccumulateHelper<(TFrom < TUntil)>::template exec<TFrom, TUntil - TFrom>(
625 std::forward<TTuple>(tuple),
627 std::forward<TFunc>(func));
635 template <
bool THasElems>
636 class TupleTypeAccumulateHelper
640 template <std::
size_t TOff, std::
size_t TRem,
typename TTuple,
typename TValue,
typename TFunc>
641 static constexpr TValue exec(
const TValue& value, TFunc&& func)
643 using Tuple =
typename std::decay<TTuple>::type;
644 static_assert(IsTuple<Tuple>::Value,
"TTuple must be std::tuple");
645 static_assert((TOff + TRem) <= std::tuple_size<Tuple>::value,
"Incorrect TRem");
647 return TupleTypeAccumulateHelper<(1U < TRem)>::
template exec<TOff + 1, TRem - 1, Tuple>(
651 func.template operator()
653 <
typename std::tuple_element<TOff, Tuple>::type>(value),
654 std::forward<TFunc>(func));
660 class TupleTypeAccumulateHelper<false>
664 template <std::
size_t TOff, std::
size_t TRem,
typename TTuple,
typename TValue,
typename TFunc>
665 static constexpr TValue exec(
const TValue& value, TFunc&& )
687 template <
typename TTuple,
typename TValue,
typename TFunc>
690 using Tuple =
typename std::decay<TTuple>::type;
692 details::TupleTypeAccumulateHelper<
693 (0U < std::tuple_size<Tuple>::value)
694 >::
template exec<0, std::tuple_size<Tuple>::value, Tuple>(
696 std::forward<TFunc>(func));
715 template <std::
size_t TFrom, std::
size_t TUntil,
typename TTuple,
typename TValue,
typename TFunc>
718 using Tuple =
typename std::decay<TTuple>::type;
719 static_assert(TFrom <= TUntil,
"TFrom mustn't be greater that TUntil");
720 static_assert(TUntil <= std::tuple_size<Tuple>::value,
"TUntil mustn't exceed size of the tuple");
722 details::TupleTypeAccumulateHelper<
724 >::
template exec<TFrom, TUntil - TFrom, Tuple>(
726 std::forward<TFunc>(func));
736 template <
typename TFirst,
typename TSecond>
743 using Type =
typename std::decay<decltype(std::tuple_cat(std::declval<TFirst>(), std::declval<TSecond>()))>::type;
748 template <
typename TField,
typename TTuple>
756 template <
bool THasElems>
757 struct TupleSelectedTypeHelper;
760 struct TupleSelectedTypeHelper<false>
762 template <std::
size_t TFromIdx, std::
size_t TToIdx, std::
size_t TCount,
typename TTuple,
typename TFunc>
763 static void exec(std::size_t idx, TFunc&& func)
765 static_assert((TFromIdx + 1) == TToIdx,
"Internal error: Bad parameters");
766 static_assert(TCount == 1,
"Internal error: Bad parameters");
767 static_cast<void>(idx);
769 using ElemType =
typename std::tuple_element<TFromIdx, TTuple>::type;
772 func.operator()<TFromIdx, ElemType>();
774 func.template operator()<TFromIdx, ElemType>();
779 template <
bool THasElems>
780 struct TupleSelectedTypeHelper
782 template <std::
size_t TFromIdx, std::
size_t TToIdx, std::
size_t TCount,
typename TTuple,
typename TFunc>
783 static void exec(std::size_t idx, TFunc&& func)
785 static_assert(1U < TCount,
"Internal error: Bad parameters");
786 static_assert(TCount == (TToIdx - TFromIdx),
"Internal error: Bad parameters");
787 static_assert(TFromIdx < TToIdx,
"Internal error: Bad parameters");
789 using Tuple =
typename std::decay<TTuple>::type;
791 static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
792 static_assert(TCount <= TupleSize,
"Incorrect TCount");
793 static_assert(0U < TCount,
"Incorrect instantiation");
797 if (idx == TFromIdx) {
798 TupleSelectedTypeHelper<false>::template exec<TFromIdx, TFromIdx + 1, 1U, TTuple>(
799 idx, std::forward<TFunc>(func));
803 static constexpr std::size_t MidIdx = TFromIdx + TCount / 2;
804 static_assert(MidIdx < TToIdx,
"Internal error: bad calculation");
805 static_assert(TFromIdx <= MidIdx,
"Internal error: bad calculation");
807 static constexpr std::size_t NextCount = TToIdx - MidIdx;
808 static constexpr
bool HasNextElems = (1U < NextCount);
810 TupleSelectedTypeHelper<HasNextElems>::template exec<MidIdx, TToIdx, NextCount, TTuple>(
811 idx, std::forward<TFunc>(func));
815 static constexpr std::size_t NextCount = MidIdx - TFromIdx;
816 static constexpr
bool HasNextElems = (1U < NextCount);
818 TupleSelectedTypeHelper<HasNextElems>::template exec<TFromIdx, MidIdx, NextCount, TTuple>(
819 idx, std::forward<TFunc>(func));
839 template <
typename TTuple,
typename TFunc>
842 using Tuple =
typename std::decay<TTuple>::type;
843 static_assert(isTuple<Tuple>(),
"Provided tupe must be std::tuple");
844 static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
845 static_assert(0U < TupleSize,
"Empty tuples are not supported");
847 details::TupleSelectedTypeHelper<(1U < TupleSize)>::
template exec<0, TupleSize, TupleSize, Tuple>(
848 idx, std::forward<TFunc>(func));
855 template <
bool THasElems>
856 struct TupleStripFirstN
858 template <std::size_t TCount,
typename TFirst,
typename... TElems>
860 typename TupleStripFirstN<
869 struct TupleStripFirstN<false>
871 template <std::size_t TCount,
typename... TElems>
872 using Type = std::tuple<TElems...>;
875 template <
typename TTuple>
876 struct TuplePackedStripFirstN;
878 template <
typename... TElems>
879 struct TuplePackedStripFirstN<std::tuple<TElems...> >
881 template <std::
size_t TCount>
883 typename TupleStripFirstN<
885 >::
template Type<TCount, TElems...>;
888 template <
bool TMustStrip>
889 struct TupleTailCheckHelpler
891 template <std::
size_t TCount,
typename TElems>
893 typename TuplePackedStripFirstN<TElems>::template Type<
897 template <
typename TTail,
typename TElems>
899 std::integral_constant<
904 (std::tuple_size<TElems>::value - std::tuple_size<TTail>::value),
912 struct TupleTailCheckHelpler<false>
914 template <
typename TTail,
typename TElems>
916 std::integral_constant<
918 std::is_same<TTail, TElems>::value
927 template <
typename TTail,
typename TTuple>
930 static_assert(isTuple<TTail>(),
"TTail param must be tuple");
931 static_assert(isTuple<TTuple>(),
"TTuple param must be tuple");
933 details::TupleTailCheckHelpler<
934 std::tuple_size<TTail>::value < std::tuple_size<TTuple>::value
935 >::template Type<TTail, TTuple>::value;
943 template <
bool THasElems>
944 class TupleTypeIsAnyOfHelper
947 template <std::
size_t TRem,
typename TTuple,
typename TFunc>
948 static constexpr
bool check(TFunc&& func)
950 using Tuple =
typename std::decay<TTuple>::type;
951 static_assert(IsTuple<Tuple>::Value,
"TTuple must be std::tuple");
952 static_assert(TRem <= std::tuple_size<Tuple>::value,
"Incorrect TRem");
953 using ElemType =
typename std::tuple_element<std::tuple_size<Tuple>::value - TRem, Tuple>::type;
957 func.operator()<ElemType>() ||
959 func.template
operator()<ElemType>() ||
961 TupleTypeIsAnyOfHelper<1U < TRem>::
template check<TRem - 1, TTuple>(
962 std::forward<TFunc>(func));
967 class TupleTypeIsAnyOfHelper<false>
971 template <std::
size_t TRem,
typename TTuple,
typename TFunc>
972 static constexpr
bool check(TFunc&&)
992 template <
typename TTuple,
typename TFunc>
995 static_assert(isTuple<TTuple>(),
"Tuple as argument is expected");
996 return details::TupleTypeIsAnyOfHelper<(0U < std::tuple_size<TTuple>::value)>::
997 template check<std::tuple_size<TTuple>::value, TTuple>(std::forward<TFunc>(func));
1004 COMMS_GNU_WARNING_POP
This file contains classes required for generic custom assertion functionality.
#define COMMS_ASSERT(expr)
Generic assert macro.
Definition: Assert.h:170
Contains various compiler related definitions.
constexpr TValue tupleTypeAccumulate(const TValue &value, TFunc &&func)
Performs "accumulate" algorithm on every type of the tuple.
Definition: Tuple.h:688
constexpr TValue tupleTypeAccumulateFromUntil(const TValue &value, TFunc &&func)
Performs "accumulate" algorithm on specified types inside the tuple.
Definition: Tuple.h:716
void tupleForEachFrom(TTuple &&tuple, TFunc &&func)
Invoke provided functor for every element in the tuple starting from element with specified index.
Definition: Tuple.h:286
constexpr bool tupleTypeIsAnyOf(TFunc &&func)
Compile time check of whether any type within a tuple has a certain condition.
Definition: Tuple.h:993
void tupleForEach(TTuple &&tuple, TFunc &&func)
Invoke provided functor for every element in the tuple.
Definition: Tuple.h:242
void tupleForEachFromUntil(TTuple &&tuple, TFunc &&func)
Invoke provided functor for every element in the tuple which indices are in range [TFromIdx,...
Definition: Tuple.h:312
void tupleForSelectedType(std::size_t idx, TFunc &&func)
Invoke provided functor for a selected type when element index is known only at run time.
Definition: Tuple.h:840
void tupleForEachType(TFunc &&func)
Invoke provided functor for every type in the tuple.
Definition: Tuple.h:387
void tupleForEachWithTemplateParamIdx(TTuple &&tuple, TFunc &&func)
Invoke provided functor for every element in the tuple while providing information about element inde...
Definition: Tuple.h:523
constexpr TValue tupleAccumulateFromUntil(TTuple &&tuple, const TValue &value, TFunc &&func)
Performs "accumulate" algorithm on every element of the tuple.
Definition: Tuple.h:617
constexpr bool tupleIsTailOf()
Compile time check of whether one tuple is a "tail" of another.
Definition: Tuple.h:928
void tupleForEachUntil(TTuple &&tuple, TFunc &&func)
Invoke provided functor for every element in the tuple until element with specified index is reached.
Definition: Tuple.h:263
void tupleForEachWithIdx(TTuple &&tuple, TFunc &&func)
Invoke provided functor for every element in the tuple while providing information about element inde...
Definition: Tuple.h:452
constexpr bool isTuple()
Check whether provided type is a variant of std::tuple.
Definition: Tuple.h:53
typename TupleAsAlignedUnion< TTuple >::Type TupleAsAlignedUnionT
Alias to TupleAsAlignedUnion::Type.
Definition: Tuple.h:188
constexpr TValue tupleAccumulate(TTuple &&tuple, const TValue &value, TFunc &&func)
Performs "accumulate" algorithm on every element of the tuple.
Definition: Tuple.h:589
Main namespace for all classes / functions of COMMS library.
Replacement to std::conditional.
Definition: type_traits.h:28
Check whether TType type is included in the tuple TTuple.
Definition: Tuple.h:94
Check whether provided type is a variant of std::tuple.
Definition: Tuple.h:35
Calculated "aligned union" storage type for all the types in provided tuple.
Definition: Tuple.h:157
void Type
Type definition is invalid for any type that is not std::tuple, will be specialised to proper value.
Definition: Tuple.h:165
Provides the type of std::tuple_cat operation.
Definition: Tuple.h:738
typename TupleCat< TField, TTuple >::Type TupleCatT
Alias to typename TupleCat<TField, TTuple>::Type.
Definition: Tuple.h:749
typename std::decay< decltype(std::tuple_cat(std::declval< TFirst >(), std::declval< TSecond >()))>::type Type
Result type of tuples concatenation.
Definition: Tuple.h:743
Replacement to some types from standard type_traits.