Tuple.h

Go to the documentation of this file.

//
// Copyright 2013 - 2026 (C). Alex Robenko. All rights reserved.
//
// SPDX-License-Identifier: MPL-2.0
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 
#pragma once
 
#include "comms/Assert.h"
#include "comms/CompileControl.h"
#include "comms/util/type_traits.h"
#include "comms/util/AlignedStorage.h"
 
#include <cstddef>
#include <tuple>
#include <type_traits>
#include <utility>
 
COMMS_GNU_WARNING_PUSH
COMMS_GNU_WARNING_DISABLE("-Wtype-limits")
 
namespace comms
{
 
namespace util
{
 
template <typename TType>
struct IsTuple
{
    static constexpr bool Value = false;
};
 
template <typename... TArgs>
struct IsTuple<std::tuple<TArgs...> >
{
    static constexpr bool Value = true;
};
 
template <typename TType>
constexpr bool isTuple()
{
    return IsTuple<TType>::Value;
}
 
//----------------------------------------
 
namespace details
{
 
template <bool THasElems, typename...>
struct IsInTupleHelper // <true>
{
    template <typename TType, typename TFirst, typename... TRest>
    using Type =
        typename comms::util::Conditional<
            std::is_same<TType, TFirst>::value
        >::template Type<
            std::true_type,
            typename IsInTupleHelper<(sizeof...(TRest) != 0U)>::template Type<TType, TRest...>
        >;
};
 
template <typename... TParams>
struct IsInTupleHelper<false, TParams...>
{
    template <typename TType, typename...>
    using Type = std::false_type;
};
 
} // namespace details
 
template <typename TTuple>
struct IsInTuple;
 
 
template <typename... TTypes>
struct IsInTuple<std::tuple<TTypes...> >
{
    template <typename TType>
    using Type =
        typename details::IsInTupleHelper<(sizeof...(TTypes) != 0U)>::template Type<TType, TTypes...>;
};
 
 
//----------------------------------------
 
namespace details
{
 
template <bool THasElems, typename...>
class TupleAsAlignedUnionHelper // <true>
{
    template <typename TElem>
    using ElemAlignmentType = std::integral_constant<std::size_t, alignof(TElem)>;
 
    template <typename TElem>
    using ElemSizeType = std::integral_constant<std::size_t, sizeof(TElem)>;
 
public:
    template <typename TElem, typename... TRest>
    using AlignmentType =
        comms::util::IntMaxBinaryOp<>::template Type<
            ElemAlignmentType<TElem>,
            typename TupleAsAlignedUnionHelper<(0U < sizeof...(TRest))>::template AlignmentType<TRest...>
        >;
 
    template <typename TElem, typename... TRest>
    using SizeType =
        comms::util::IntMaxBinaryOp<>::template Type<
            ElemSizeType<TElem>,
            typename TupleAsAlignedUnionHelper<(0U < sizeof...(TRest))>::template SizeType<TRest...>
        >;
};
 
template <typename... TParams>
class TupleAsAlignedUnionHelper<false, TParams...>
{
public:
    template <typename...>
    using AlignmentType = std::integral_constant<std::size_t, 0U>;
 
    template <typename...>
    using SizeType = std::integral_constant<std::size_t, 0U>;
};
 
} // namespace details
 
template <typename TTuple>
struct TupleAsAlignedUnion
{
    static_assert(IsTuple<TTuple>::Value, "TTuple must be std::tuple");
 
    using Type = void;
};
 
template <typename... TTypes>
class TupleAsAlignedUnion<std::tuple<TTypes...> >
{
    using AlignmentType =
        typename details::TupleAsAlignedUnionHelper<(0U < sizeof...(TTypes))>::template AlignmentType<TTypes...>;
 
    using SizeType =
        typename details::TupleAsAlignedUnionHelper<(0U < sizeof...(TTypes))>::template SizeType<TTypes...>;
public:
    using Type = comms::util::AlignedStorage<SizeType::value, AlignmentType::value>;
};
 
template <typename TTuple>
using TupleAsAlignedUnionT = typename TupleAsAlignedUnion<TTuple>::Type;
 
//----------------------------------------
 
namespace details
{
 
template <bool THasElems>
struct TupleForEachHelper
{
    template <std::size_t TOff, std::size_t TRem, typename TTuple, typename TFunc>
    static void exec(TTuple&& tuple, TFunc&& func)
    {
        using Tuple = typename std::decay<TTuple>::type;
        static_assert(IsTuple<Tuple>::Value, "TTuple must be std::tuple");
        static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
        static constexpr std::size_t OffsetedRem = TRem + TOff;
        static_assert(OffsetedRem <= TupleSize, "Incorrect parameters");
 
        static constexpr std::size_t Idx = TupleSize - OffsetedRem;
        static constexpr std::size_t NextRem = TRem - 1;
        static constexpr bool HasElemsToProcess = (NextRem != 0U);
        func(std::get<Idx>(std::forward<TTuple>(tuple)));
        TupleForEachHelper<HasElemsToProcess>::template exec<TOff, NextRem>(
            std::forward<TTuple>(tuple),
            std::forward<TFunc>(func));
    }
};
 
template <>
struct TupleForEachHelper<false>
{
    template <std::size_t TOff, std::size_t TRem, typename TTuple, typename TFunc>
    static void exec(TTuple&& tuple, TFunc&& func)
    {
        static_cast<void>(tuple);
        static_cast<void>(func);
    }
};
 
}  // namespace details
 
template <typename TTuple, typename TFunc>
void tupleForEach(TTuple&& tuple, TFunc&& func)
{
    using Tuple = typename std::decay<TTuple>::type;
    static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
    static constexpr bool HasTupleElems = (TupleSize != 0U);
 
    details::TupleForEachHelper<HasTupleElems>::template exec<0, TupleSize>(
        std::forward<TTuple>(tuple),
        std::forward<TFunc>(func));
}
 
template <std::size_t TIdx, typename TTuple, typename TFunc>
void tupleForEachUntil(TTuple&& tuple, TFunc&& func)
{
    using Tuple = typename std::decay<TTuple>::type;
    static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
    static_assert(TIdx <= TupleSize,
        "The index is too big.");
 
    static constexpr bool HasTupleElems = (TIdx != 0U);
 
    details::TupleForEachHelper<HasTupleElems>::template exec<TupleSize - TIdx, TIdx>(
        std::forward<TTuple>(tuple),
        std::forward<TFunc>(func));
}
 
template <std::size_t TIdx, typename TTuple, typename TFunc>
void tupleForEachFrom(TTuple&& tuple, TFunc&& func)
{
    using Tuple = typename std::decay<TTuple>::type;
    static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
    static_assert(TIdx <= TupleSize,
        "The index is too big.");
    static constexpr std::size_t RemCount = TupleSize - TIdx;
    static constexpr bool HasTupleElems = (RemCount != 0U);
 
    details::TupleForEachHelper<HasTupleElems>::template exec<0, RemCount>(
        std::forward<TTuple>(tuple),
        std::forward<TFunc>(func));
}
 
template <std::size_t TFromIdx, std::size_t TUntilIdx, typename TTuple, typename TFunc>
void tupleForEachFromUntil(TTuple&& tuple, TFunc&& func)
{
    using Tuple = typename std::decay<TTuple>::type;
    static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
    static_assert(TFromIdx <= TupleSize,
        "The from index is too big.");
 
    static_assert(TUntilIdx <= TupleSize,
        "The until index is too big.");
 
    static_assert(TFromIdx <= TUntilIdx,
        "The from index must be less than until index.");
 
    static constexpr std::size_t FieldsCount = TUntilIdx - TFromIdx;
    static constexpr bool HasTupleElems = (FieldsCount != 0U);
 
    details::TupleForEachHelper<HasTupleElems>::template exec<TupleSize - TUntilIdx, FieldsCount>(
        std::forward<TTuple>(tuple),
        std::forward<TFunc>(func));
}
//----------------------------------------
 
namespace details
{
 
template <bool THasElems>
struct TupleForEachTypeHelper
{
    template <std::size_t TRem, typename TTuple, typename TFunc>
    static void exec(TFunc&& func)
    {
        using Tuple = typename std::decay<TTuple>::type;
        static_assert(IsTuple<Tuple>::Value, "TTuple must be std::tuple");
        static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
        static_assert(TRem <= TupleSize, "Incorrect TRem");
 
        static constexpr std::size_t Idx = TupleSize - TRem;
        static constexpr std::size_t NextRem = TRem - 1U;
        static constexpr bool NextHasElems = (NextRem != 0U);
 
        using ElemType = typename std::tuple_element<Idx, Tuple>::type;
#if COMMS_IS_MSVC
        // VS compiler
        func.operator()<ElemType>();
#else // #if COMMS_IS_MSVC
        func.template operator()<ElemType>();
#endif // #if COMMS_IS_MSVC
        TupleForEachTypeHelper<NextHasElems>::template exec<NextRem, TTuple>(
            std::forward<TFunc>(func));
    }
};
 
template <>
struct TupleForEachTypeHelper<false>
{
    template <std::size_t TRem, typename TTuple, typename TFunc>
    static void exec(TFunc&& func)
    {
        static_cast<void>(func);
    }
};
 
}  // namespace details
 
template <typename TTuple, typename TFunc>
void tupleForEachType(TFunc&& func)
{
    using Tuple = typename std::decay<TTuple>::type;
    static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
    static constexpr bool HasElems = (TupleSize != 0U);
 
    details::TupleForEachTypeHelper<HasElems>::template exec<TupleSize, Tuple>(
        std::forward<TFunc>(func));
}
//----------------------------------------
 
namespace details
{
 
template <bool THasElems>
struct TupleForEachWithIdxHelper
{
    template <std::size_t TRem, typename TTuple, typename TFunc>
    static void exec(TTuple&& tuple, TFunc&& func)
    {
        using Tuple = typename std::decay<TTuple>::type;
        static_assert(IsTuple<Tuple>::Value, "TTuple must be std::tuple");
        static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
        static_assert(TRem <= TupleSize, "Incorrect TRem");
 
        static constexpr std::size_t Idx = TupleSize - TRem;
        static constexpr std::size_t NextRem = TRem - 1;
        static constexpr bool NextHasElems = (NextRem != 0U);
 
        func(std::get<Idx>(std::forward<TTuple>(tuple)), Idx);
        TupleForEachWithIdxHelper<NextHasElems>::template exec<NextRem>(
            std::forward<TTuple>(tuple),
            std::forward<TFunc>(func));
    }
};
 
template <>
struct TupleForEachWithIdxHelper<false>
{
    template <std::size_t TRem, typename TTuple, typename TFunc>
    static void exec(TTuple&& tuple, TFunc&& func)
    {
        static_cast<void>(tuple);
        static_cast<void>(func);
    }
};
 
}  // namespace details
 
template <typename TTuple, typename TFunc>
void tupleForEachWithIdx(TTuple&& tuple, TFunc&& func)
{
    using Tuple = typename std::decay<TTuple>::type;
    static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
    static constexpr bool HasElems = (TupleSize != 0U);
 
    details::TupleForEachWithIdxHelper<HasElems>::template exec<TupleSize>(
        std::forward<TTuple>(tuple),
        std::forward<TFunc>(func));
}
 
namespace details
{
 
template <bool THasElems>
struct TupleForEachWithTemplateParamIdxHelper
{
    template <std::size_t TRem, typename TTuple, typename TFunc>
    static void exec(TTuple&& tuple, TFunc&& func)
    {
        using Tuple = typename std::decay<TTuple>::type;
        static_assert(IsTuple<Tuple>::Value, "TTuple must be std::tuple");
        static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
        static_assert(TRem <= TupleSize, "Incorrect TRem");
 
        static constexpr std::size_t Idx = TupleSize - TRem;
        static constexpr std::size_t NextRem = TRem - 1;
        static constexpr bool NextHasElems = (NextRem != 0U);
 
#if COMMS_IS_MSVC
        // VS compiler
        func.operator()<Idx>(std::get<Idx>(std::forward<TTuple>(tuple)));
#else // #if COMMS_IS_MSVC
        func.template operator()<Idx>(std::get<Idx>(std::forward<TTuple>(tuple)));
#endif // #if COMMS_IS_MSVC
        TupleForEachWithTemplateParamIdxHelper<NextHasElems>::template exec<NextRem>(
            std::forward<TTuple>(tuple),
            std::forward<TFunc>(func));
    }
};
 
template <>
struct TupleForEachWithTemplateParamIdxHelper<false>
{
    template <std::size_t TRem, typename TTuple, typename TFunc>
    static void exec(TTuple&& tuple, TFunc&& func)
    {
        static_cast<void>(tuple);
        static_cast<void>(func);
    }
};
 
}  // namespace details
 
 
template <typename TTuple, typename TFunc>
void tupleForEachWithTemplateParamIdx(TTuple&& tuple, TFunc&& func)
{
    using Tuple = typename std::decay<TTuple>::type;
    static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
    static constexpr bool HasElems = (TupleSize != 0U);
 
    details::TupleForEachWithTemplateParamIdxHelper<HasElems>::template exec<TupleSize>(
        std::forward<TTuple>(tuple),
        std::forward<TFunc>(func));
}
 
//----------------------------------------
 
namespace details
{
 
template <bool THasElems>
struct TupleAccumulateHelper
{
    template <std::size_t TOff, std::size_t TRem, typename TTuple, typename TValue, typename TFunc>
    static constexpr TValue exec(TTuple&& tuple, const TValue& value, TFunc&& func)
    {
        using Tuple = typename std::decay<TTuple>::type;
        static_assert(IsTuple<Tuple>::Value, "TTuple must be std::tuple");
        static_assert((TOff + TRem) <= std::tuple_size<Tuple>::value, "Incorrect params");
 
        return
            TupleAccumulateHelper<(1U < TRem)>::template exec<TOff + 1, TRem - 1U>(
                std::forward<TTuple>(tuple),
                func(value, std::get<TOff>(std::forward<TTuple>(tuple))),
                std::forward<TFunc>(func));
    }
};
 
template <>
struct TupleAccumulateHelper<false>
{
    template <std::size_t TOff, std::size_t TRem, typename TTuple, typename TValue, typename TFunc>
    static constexpr TValue exec(TTuple&& /* tuple */, const TValue& value, TFunc&& /* func */)
    {
        return value;
    }
};
 
}  // namespace details
 
template <typename TTuple, typename TValue, typename TFunc>
constexpr TValue tupleAccumulate(TTuple&& tuple, const TValue& value, TFunc&& func)
{
    using Tuple = typename std::decay<TTuple>::type;
 
    return details::TupleAccumulateHelper<std::tuple_size<Tuple>::value != 0>::template exec<0, std::tuple_size<Tuple>::value>(
                std::forward<TTuple>(tuple),
                value,
                std::forward<TFunc>(func));
}
 
template <std::size_t TFrom, std::size_t TUntil, typename TTuple, typename TValue, typename TFunc>
constexpr TValue tupleAccumulateFromUntil(TTuple&& tuple, const TValue& value, TFunc&& func)
{
    using Tuple = typename std::decay<TTuple>::type;
 
    static_assert(TFrom <= TUntil, "TFrom mustn't be greater that TUntil");
    static_assert(TUntil <= std::tuple_size<Tuple>::value, "TUntil mustn't exceed size of the tuple");
 
    return details::TupleAccumulateHelper<(TFrom < TUntil)>::template exec<TFrom, TUntil - TFrom>(
                std::forward<TTuple>(tuple),
                value,
                std::forward<TFunc>(func));
}
 
//----------------------------------------
 
namespace details
{
 
template <bool THasElems>
class TupleTypeAccumulateHelper
{
 
public:
    template <std::size_t TOff, std::size_t TRem, typename TTuple, typename TValue, typename TFunc>
    static constexpr TValue exec(const TValue& value, TFunc&& func)
    {
        using Tuple = typename std::decay<TTuple>::type;
        static_assert(IsTuple<Tuple>::Value, "TTuple must be std::tuple");
        static_assert((TOff + TRem) <= std::tuple_size<Tuple>::value, "Incorrect TRem");
 
        return TupleTypeAccumulateHelper<(1U < TRem)>::template exec<TOff + 1, TRem - 1, Tuple>(
#if COMMS_IS_MSVC
            func.operator()
#else // #if COMMS_IS_MSVC
            func.template operator()
#endif // #if COMMS_IS_MSVC
            <typename std::tuple_element<TOff, Tuple>::type>(value),
            std::forward<TFunc>(func));
    }
 
};
 
template <>
class TupleTypeAccumulateHelper<false>
{
 
public:
    template <std::size_t TOff, std::size_t TRem, typename TTuple, typename TValue, typename TFunc>
    static constexpr TValue exec(const TValue& value, TFunc&& /* func */)
    {
        return value;
    }
};
 
}  // namespace details
 
template <typename TTuple, typename TValue, typename TFunc>
constexpr TValue tupleTypeAccumulate(const TValue& value, TFunc&& func)
{
    using Tuple = typename std::decay<TTuple>::type;
    return
        details::TupleTypeAccumulateHelper<
            (0U < std::tuple_size<Tuple>::value)
        >::template exec<0, std::tuple_size<Tuple>::value, Tuple>(
            value,
            std::forward<TFunc>(func));
}
 
template <std::size_t TFrom, std::size_t TUntil, typename TTuple, typename TValue, typename TFunc>
constexpr TValue tupleTypeAccumulateFromUntil(const TValue& value, TFunc&& func)
{
    using Tuple = typename std::decay<TTuple>::type;
    static_assert(TFrom <= TUntil, "TFrom mustn't be greater that TUntil");
    static_assert(TUntil <= std::tuple_size<Tuple>::value, "TUntil mustn't exceed size of the tuple");
    return
        details::TupleTypeAccumulateHelper<
            (TFrom < TUntil)
        >::template exec<TFrom, TUntil - TFrom, Tuple>(
            value,
            std::forward<TFunc>(func));
}
 
//----------------------------------------
 
template <typename TFirst, typename TSecond>
struct TupleCat
{
    static_assert(IsTuple<TFirst>::Value, "TFirst must be tuple");
    static_assert(IsTuple<TSecond>::Value, "TSecond must be tuple");
 
    using Type = typename std::decay<decltype(std::tuple_cat(std::declval<TFirst>(), std::declval<TSecond>()))>::type;
};
 
template <typename TField, typename TTuple>
using TupleCatT = typename TupleCat<TField, TTuple>::Type;
 
//----------------------------------------
 
namespace details
{
 
template <bool THasElems>
struct TupleSelectedTypeHelper;
 
template <>
struct TupleSelectedTypeHelper<false>
{
    template <std::size_t TFromIdx, std::size_t TToIdx, std::size_t TCount, typename TTuple, typename TFunc>
    static void exec(std::size_t idx, TFunc&& func)
    {
        static_assert((TFromIdx + 1) == TToIdx, "Internal error: Bad parameters");
        static_assert(TCount == 1, "Internal error: Bad parameters");
        static_cast<void>(idx);
        COMMS_ASSERT(idx == TFromIdx);
        using ElemType = typename std::tuple_element<TFromIdx, TTuple>::type;
#if COMMS_IS_MSVC
        // VS compiler
        func.operator()<TFromIdx, ElemType>();
#else // #if COMMS_IS_MSVC
        func.template operator()<TFromIdx, ElemType>();
#endif // #if COMMS_IS_MSVC
    }
};
 
template <bool THasElems>
struct TupleSelectedTypeHelper
{
    template <std::size_t TFromIdx, std::size_t TToIdx, std::size_t TCount, typename TTuple, typename TFunc>
    static void exec(std::size_t idx, TFunc&& func)
    {
        static_assert(1U < TCount, "Internal error: Bad parameters");
        static_assert(TCount == (TToIdx - TFromIdx), "Internal error: Bad parameters");
        static_assert(TFromIdx < TToIdx, "Internal error: Bad parameters");
 
        using Tuple = typename std::decay<TTuple>::type;
        static_assert(IsTuple<Tuple>::Value, "TTuple must be std::tuple");
        static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
        static_assert(TCount <= TupleSize, "Incorrect TCount");
        static_assert(0U < TCount, "Incorrect instantiation");
 
        COMMS_ASSERT(TFromIdx <= idx);
        COMMS_ASSERT(idx < TToIdx);
        if (idx == TFromIdx) {
            TupleSelectedTypeHelper<false>::template exec<TFromIdx, TFromIdx + 1, 1U, TTuple>(
                idx, std::forward<TFunc>(func));
            return;
        }
 
        static constexpr std::size_t MidIdx = TFromIdx + TCount / 2;
        static_assert(MidIdx < TToIdx, "Internal error: bad calculation");
        static_assert(TFromIdx <= MidIdx, "Internal error: bad calculation");
        if (MidIdx <= idx) {
            static constexpr std::size_t NextCount = TToIdx - MidIdx;
            static constexpr bool HasNextElems = (1U < NextCount);
 
            TupleSelectedTypeHelper<HasNextElems>::template exec<MidIdx, TToIdx, NextCount, TTuple>(
                idx, std::forward<TFunc>(func));
            return;
        }
 
        static constexpr std::size_t NextCount = MidIdx - TFromIdx;
        static constexpr bool HasNextElems = (1U < NextCount);
 
        TupleSelectedTypeHelper<HasNextElems>::template exec<TFromIdx, MidIdx, NextCount, TTuple>(
            idx, std::forward<TFunc>(func));
    }
};
 
}  // namespace details
 
template <typename TTuple, typename TFunc>
void tupleForSelectedType(std::size_t idx, TFunc&& func)
{
    using Tuple = typename std::decay<TTuple>::type;
    static_assert(isTuple<Tuple>(), "Provided tupe must be std::tuple");
    static constexpr std::size_t TupleSize = std::tuple_size<Tuple>::value;
    static_assert(0U < TupleSize, "Empty tuples are not supported");
 
    details::TupleSelectedTypeHelper<(1U < TupleSize)>::template exec<0, TupleSize, TupleSize, Tuple>(
        idx, std::forward<TFunc>(func));
}
//----------------------------------------
 
namespace details
{
 
template <bool THasElems>
struct TupleStripFirstN
{
    template <std::size_t TCount, typename TFirst, typename... TElems>
    using Type =
        typename TupleStripFirstN<
            (1U < TCount)
        >::template Type<
            TCount - 1,
            TElems...
        >;
};
 
template <>
struct TupleStripFirstN<false>
{
    template <std::size_t TCount, typename... TElems>
    using Type = std::tuple<TElems...>;
};
 
template <typename TTuple>
struct TuplePackedStripFirstN;
 
template <typename... TElems>
struct TuplePackedStripFirstN<std::tuple<TElems...> >
{
    template <std::size_t TCount>
    using Type =
        typename TupleStripFirstN<
            (0 < TCount)
        >::template Type<TCount, TElems...>;
};
 
template <bool TMustStrip>
struct TupleTailCheckHelpler
{
    template <std::size_t TCount, typename TElems>
    using StrippedTail =
        typename TuplePackedStripFirstN<TElems>::template Type<
            TCount
        >;
 
    template <typename TTail, typename TElems>
    using Type =
        std::integral_constant<
            bool,
            std::is_same<
                TTail,
                StrippedTail<
                    (std::tuple_size<TElems>::value - std::tuple_size<TTail>::value),
                    TElems
                >
            >::value
        >;
};
 
template <>
struct TupleTailCheckHelpler<false>
{
    template <typename TTail, typename TElems>
    using Type =
        std::integral_constant<
            bool,
            std::is_same<TTail, TElems>::value
    >;
};
 
} // namespace details
 
template <typename TTail, typename TTuple>
constexpr bool tupleIsTailOf()
{
    static_assert(isTuple<TTail>(), "TTail param must be tuple");
    static_assert(isTuple<TTuple>(), "TTuple param must be tuple");
    return
        details::TupleTailCheckHelpler<
            std::tuple_size<TTail>::value < std::tuple_size<TTuple>::value
        >::template Type<TTail, TTuple>::value;
}
 
//----------------------------------------
 
namespace details
{
 
template <bool THasElems>
class TupleTypeIsAnyOfHelper
{
public:
    template <std::size_t TRem, typename TTuple, typename TFunc>
    static constexpr bool check(TFunc&& func)
    {
        using Tuple = typename std::decay<TTuple>::type;
        static_assert(IsTuple<Tuple>::Value, "TTuple must be std::tuple");
        static_assert(TRem <= std::tuple_size<Tuple>::value, "Incorrect TRem");
        using ElemType = typename std::tuple_element<std::tuple_size<Tuple>::value - TRem, Tuple>::type;
        return
#if COMMS_IS_MSVC
            // VS compiler
            func.operator()<ElemType>() ||
#else // #if COMMS_IS_MSVC
            func.template operator()<ElemType>() ||
#endif // #if COMMS_IS_MSVC
            TupleTypeIsAnyOfHelper<1U < TRem>::template check<TRem - 1, TTuple>(
                std::forward<TFunc>(func));
    }
};
 
template <>
class TupleTypeIsAnyOfHelper<false>
{
 
public:
    template <std::size_t TRem, typename TTuple, typename TFunc>
    static constexpr bool check(TFunc&&)
    {
        return false;
    }
};
 
}
 
template <typename TTuple, typename TFunc>
constexpr bool tupleTypeIsAnyOf(TFunc&& func)
{
    static_assert(isTuple<TTuple>(), "Tuple as argument is expected");
    return details::TupleTypeIsAnyOfHelper<(0U < std::tuple_size<TTuple>::value)>::
            template check<std::tuple_size<TTuple>::value, TTuple>(std::forward<TFunc>(func));
}
 
}  // namespace util
 
}  // namespace comms
 
COMMS_GNU_WARNING_POP