From 05fd6fbcae3f05d09b46179fda5a912e3c66f373 Mon Sep 17 00:00:00 2001
From: Mathew Sutcliffe <oktal3700@gmail.com>
Date: Thu, 5 Jun 2014 23:57:07 +0100
Subject: [PATCH] refs #245 removed fake variadics for tuples and predicates

---
 src/blackmisc/predicates.h    |  56 ---
 src/blackmisc/tuple.h         | 629 ----------------------------------
 src/blackmisc/tuple_private.h |  31 --
 3 files changed, 716 deletions(-)

diff --git a/src/blackmisc/predicates.h b/src/blackmisc/predicates.h
index 73a9bbe02..e020eb479 100644
--- a/src/blackmisc/predicates.h
+++ b/src/blackmisc/predicates.h
@@ -18,8 +18,6 @@ namespace BlackMisc
     namespace Predicates
     {
 
-#ifdef Q_COMPILER_VARIADIC_TEMPLATES
-
         namespace Private
         {
 
@@ -89,60 +87,6 @@ namespace BlackMisc
             return typename Private::MemberLess<T, Ts...>(vs...);
         }
 
-#else //!Q_COMPILER_VARIADIC_TEMPLATES
-
-        template <class T, class M1, class V1>
-        typename std::function<bool(const T &)> MemberEqual(M1 m1, V1 v1)
-        {
-            return [ = ](const T & obj) -> bool { return (obj.*m1)() == v1; };
-        }
-
-        template <class T, class M1, class V1, class M2, class V2>
-        typename std::function<bool(const T &)> MemberEqual(M1 m1, V1 v1, M2 m2, V2 v2)
-        {
-            return [ = ](const T & obj) -> bool
-            {
-                return (obj.*m1)() == v1 &&
-                (obj.*m2)() == v2;
-            };
-        }
-
-        template <class T, class M1, class V1, class M2, class V2, class M3, class V3>
-        typename std::function<bool(const T &)> MemberEqual(M1 m1, V1 v1, M2 m2, V2 v2, M3 m3, V3 v3)
-        {
-            return [ = ](const T & obj) -> bool
-            {
-                return (obj.*m1)() == v1 &&
-                (obj.*m2)() == v2 &&
-                (obj.*m3)() == v3;
-            };
-        }
-
-        template <class T, class M1>
-        typename std::function<bool(const T &, const T &)> MemberLess(M1 m1)
-        {
-            return [ = ](const T & a, const T & b) -> bool { return (a.*m1)() < (b.*m1)(); };
-        }
-
-        template <class T, class M1, class M2>
-        typename std::function<bool(const T &, const T &)> MemberLess(M1 m1, M2 m2)
-        {
-            return [ = ](const T & a, const T & b) -> bool { if ((a.*m1)() != (b.*m1)()) return (a.*m1)() < (b.*m1)();
-                    return (a.*m2)() < (b.*m2)();
-                                                           };
-    }
-
-    template <class T, class M1, class M2, class M3>
-    typename std::function<bool(const T &, const T &)> MemberLess(M1 m1, M2 m2, M3 m3)
-        {
-            return [ = ](const T & a, const T & b) -> bool { if ((a.*m1)() != (b.*m1)()) return (a.*m1)() < (b.*m1)();
-                    if ((a.*m2)() != (b.*m2)()) return (a.*m2)() < (b.*m2)();
-                        return (a.*m3)() < (b.*m3)();
-                                                               };
-    }
-
-#endif //!Q_COMPILER_VARIADIC_TEMPLATES
-
     } //namespace Predicates
 
 } //namespace BlackMisc
diff --git a/src/blackmisc/tuple.h b/src/blackmisc/tuple.h
index c52ac5d75..684bf72ca 100644
--- a/src/blackmisc/tuple.h
+++ b/src/blackmisc/tuple.h
@@ -163,8 +163,6 @@ namespace BlackMisc
     // Alternative would be to qualify all our invokations of the global qHash as ::qHash.
     using ::qHash;
 
-#ifdef Q_COMPILER_VARIADIC_TEMPLATES
-
     /*!
      * \brief   Works like std::tie but with special handling for any argument which are tuples.
      * \details Returns a tuple of references to its arguments which can be used in the same way as
@@ -263,633 +261,6 @@ namespace BlackMisc
         Private::TupleHelper<sizeof...(Ts)>::deserializeJson(json, members, tu);
     }
 
-
-#else // !Q_COMPILER_VARIADIC_TEMPLATES
-
-    template <class T0>
-    auto tie(T0 &&arg0)
-        -> decltype(std::make_tuple(Private::tieHelper(arg0)))
-    {
-        return std::make_tuple(Private::tieHelper(arg0));
-    }
-
-    template <class T0, class T1>
-    auto tie(T0 &&arg0, T1 &&arg1)
-        -> decltype(std::make_tuple(Private::tieHelper(arg0), Private::tieHelper(arg1)))
-    {
-        return std::make_tuple(Private::tieHelper(arg0), Private::tieHelper(arg1));
-    }
-
-    template <class T0, class T1, class T2>
-    auto tie(T0 &&arg0, T1 &&arg1, T2 &&arg2)
-        -> decltype(std::make_tuple(Private::tieHelper(arg0), Private::tieHelper(arg1), Private::tieHelper(arg2)))
-    {
-        return std::make_tuple(Private::tieHelper(arg0), Private::tieHelper(arg1), Private::tieHelper(arg2));
-    }
-
-    template <class T0, class T1, class T2, class T3>
-    auto tie(T0 &&arg0, T1 &&arg1, T2 &&arg2, T3 &&arg3)
-        -> decltype(std::make_tuple(Private::tieHelper(arg0), Private::tieHelper(arg1), Private::tieHelper(arg2), Private::tieHelper(arg3)))
-    {
-        return std::make_tuple(Private::tieHelper(arg0), Private::tieHelper(arg1), Private::tieHelper(arg2), Private::tieHelper(arg3));
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4>
-    auto tie(T0 &&arg0, T1 &&arg1, T2 &&arg2, T3 &&arg3, T4 &&arg4)
-        -> decltype(std::make_tuple(Private::tieHelper(arg0), Private::tieHelper(arg1), Private::tieHelper(arg2), Private::tieHelper(arg3), Private::tieHelper(arg4)))
-    {
-        return std::make_tuple(Private::tieHelper(arg0), Private::tieHelper(arg1), Private::tieHelper(arg2), Private::tieHelper(arg3), Private::tieHelper(arg4));
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5>
-    auto tie(T0 &&arg0, T1 &&arg1, T2 &&arg2, T3 &&arg3, T4 &&arg4, T5 &&arg5)
-        -> decltype(std::make_tuple(Private::tieHelper(arg0), Private::tieHelper(arg1), Private::tieHelper(arg2), Private::tieHelper(arg3), Private::tieHelper(arg4),
-                                    Private::tieHelper(arg5)))
-    {
-        return std::make_tuple(Private::tieHelper(arg0), Private::tieHelper(arg1), Private::tieHelper(arg2), Private::tieHelper(arg3), Private::tieHelper(arg4),
-                               Private::tieHelper(arg5));
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
-    auto tie(T0 &&arg0, T1 &&arg1, T2 &&arg2, T3 &&arg3, T4 &&arg4, T5 &&arg5, T6 &&arg6)
-        -> decltype(std::make_tuple(Private::tieHelper(arg0), Private::tieHelper(arg1), Private::tieHelper(arg2), Private::tieHelper(arg3), Private::tieHelper(arg4),
-                                    Private::tieHelper(arg5), Private::tieHelper(arg6)))
-    {
-        return std::make_tuple(Private::tieHelper(arg0), Private::tieHelper(arg1), Private::tieHelper(arg2), Private::tieHelper(arg3), Private::tieHelper(arg4),
-                               Private::tieHelper(arg5), Private::tieHelper(arg6));
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-    auto tie(T0 &&arg0, T1 &&arg1, T2 &&arg2, T3 &&arg3, T4 &&arg4, T5 &&arg5, T6 &&arg6, T7 &&arg7)
-        -> decltype(std::make_tuple(Private::tieHelper(arg0), Private::tieHelper(arg1), Private::tieHelper(arg2), Private::tieHelper(arg3), Private::tieHelper(arg4),
-                                    Private::tieHelper(arg5), Private::tieHelper(arg6), Private::tieHelper(arg7)))
-    {
-        return std::make_tuple(Private::tieHelper(arg0), Private::tieHelper(arg1), Private::tieHelper(arg2), Private::tieHelper(arg3), Private::tieHelper(arg4),
-                               Private::tieHelper(arg5), Private::tieHelper(arg6), Private::tieHelper(arg7));
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
-    auto tie(T0 &&arg0, T1 &&arg1, T2 &&arg2, T3 &&arg3, T4 &&arg4, T5 &&arg5, T6 &&arg6, T7 &&arg7, T8 &&arg8)
-        -> decltype(std::make_tuple(Private::tieHelper(arg0), Private::tieHelper(arg1), Private::tieHelper(arg2), Private::tieHelper(arg3), Private::tieHelper(arg4),
-                                    Private::tieHelper(arg5), Private::tieHelper(arg6), Private::tieHelper(arg7), Private::tieHelper(arg8)))
-    {
-        return std::make_tuple(Private::tieHelper(arg0), Private::tieHelper(arg1), Private::tieHelper(arg2), Private::tieHelper(arg3), Private::tieHelper(arg4),
-                               Private::tieHelper(arg5), Private::tieHelper(arg6), Private::tieHelper(arg7), Private::tieHelper(arg8));
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
-    auto tie(T0 &&arg0, T1 &&arg1, T2 &&arg2, T3 &&arg3, T4 &&arg4, T5 &&arg5, T6 &&arg6, T7 &&arg7, T8 &&arg8, T9 &&arg9)
-        -> decltype(std::make_tuple(Private::tieHelper(arg0), Private::tieHelper(arg1), Private::tieHelper(arg2), Private::tieHelper(arg3), Private::tieHelper(arg4),
-                                    Private::tieHelper(arg5), Private::tieHelper(arg6), Private::tieHelper(arg7), Private::tieHelper(arg8), Private::tieHelper(arg9)))
-    {
-        return std::make_tuple(Private::tieHelper(arg0), Private::tieHelper(arg1), Private::tieHelper(arg2), Private::tieHelper(arg3), Private::tieHelper(arg4),
-                               Private::tieHelper(arg5), Private::tieHelper(arg6), Private::tieHelper(arg7), Private::tieHelper(arg8), Private::tieHelper(arg9));
-    }
-
-    inline int compare(std::tuple<> a, std::tuple<> b)
-    {
-        return Private::TupleHelper<0>::compare(a, b);
-    }
-
-    template <class T0>
-    int compare(std::tuple<T0> a, std::tuple<T0> b)
-    {
-        return Private::TupleHelper<1>::compare(a, b);
-    }
-
-    template <class T0, class T1>
-    int compare(std::tuple<T0, T1> a, std::tuple<T0, T1> b)
-    {
-        return Private::TupleHelper<2>::compare(a, b);
-    }
-
-    template <class T0, class T1, class T2>
-    int compare(std::tuple<T0, T1, T2> a, std::tuple<T0, T1, T2> b)
-    {
-        return Private::TupleHelper<3>::compare(a, b);
-    }
-
-    template <class T0, class T1, class T2, class T3>
-    int compare(std::tuple<T0, T1, T2, T3> a, std::tuple<T0, T1, T2, T3> b)
-    {
-        return Private::TupleHelper<4>::compare(a, b);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4>
-    int compare(std::tuple<T0, T1, T2, T3, T4> a, std::tuple<T0, T1, T2, T3, T4> b)
-    {
-        return Private::TupleHelper<5>::compare(a, b);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5>
-    int compare(std::tuple<T0, T1, T2, T3, T4, T5> a, std::tuple<T0, T1, T2, T3, T4, T5> b)
-    {
-        return Private::TupleHelper<6>::compare(a, b);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
-    int compare(std::tuple<T0, T1, T2, T3, T4, T5, T6> a, std::tuple<T0, T1, T2, T3, T4, T5, T6> b)
-    {
-        return Private::TupleHelper<7>::compare(a, b);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-    int compare(std::tuple<T0, T1, T2, T3, T4, T5, T6, T7> a, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7> b)
-    {
-        return Private::TupleHelper<8>::compare(a, b);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
-    int compare(std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8> a, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8> b)
-    {
-        return Private::TupleHelper<9>::compare(a, b);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
-    int compare(std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> a, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> b)
-    {
-        return Private::TupleHelper<10>::compare(a, b);
-    }
-
-    inline QDBusArgument &operator <<(QDBusArgument &arg, std::tuple<> tu)
-    {
-        return Private::TupleHelper<0>::marshall(arg, tu);
-    }
-
-    template <class T0>
-    QDBusArgument &operator <<(QDBusArgument &arg, std::tuple<T0> tu)
-    {
-        return Private::TupleHelper<1>::marshall(arg, tu);
-    }
-
-    template <class T0, class T1>
-    QDBusArgument &operator <<(QDBusArgument &arg, std::tuple<T0, T1> tu)
-    {
-        return Private::TupleHelper<2>::marshall(arg, tu);
-    }
-
-    template <class T0, class T1, class T2>
-    QDBusArgument &operator <<(QDBusArgument &arg, std::tuple<T0, T1, T2> tu)
-    {
-        return Private::TupleHelper<3>::marshall(arg, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3>
-    QDBusArgument &operator <<(QDBusArgument &arg, std::tuple<T0, T1, T2, T3> tu)
-    {
-        return Private::TupleHelper<4>::marshall(arg, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4>
-    QDBusArgument &operator <<(QDBusArgument &arg, std::tuple<T0, T1, T2, T3, T4> tu)
-    {
-        return Private::TupleHelper<5>::marshall(arg, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5>
-    QDBusArgument &operator <<(QDBusArgument &arg, std::tuple<T0, T1, T2, T3, T4, T5> tu)
-    {
-        return Private::TupleHelper<6>::marshall(arg, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
-    QDBusArgument &operator <<(QDBusArgument &arg, std::tuple<T0, T1, T2, T3, T4, T5, T6> tu)
-    {
-        return Private::TupleHelper<7>::marshall(arg, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-    QDBusArgument &operator <<(QDBusArgument &arg, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7> tu)
-    {
-        return Private::TupleHelper<8>::marshall(arg, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
-    QDBusArgument &operator <<(QDBusArgument &arg, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8> tu)
-    {
-        return Private::TupleHelper<9>::marshall(arg, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
-    QDBusArgument &operator <<(QDBusArgument &arg, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> tu)
-    {
-        return Private::TupleHelper<10>::marshall(arg, tu);
-    }
-
-    inline const QDBusArgument &operator >>(const QDBusArgument &arg, std::tuple<> tu)
-    {
-        return Private::TupleHelper<0>::unmarshall(arg, tu);
-    }
-
-    template <class T0>
-    const QDBusArgument &operator >>(const QDBusArgument &arg, std::tuple<T0> tu)
-    {
-        return Private::TupleHelper<1>::unmarshall(arg, tu);
-    }
-
-    template <class T0, class T1>
-    const QDBusArgument &operator >>(const QDBusArgument &arg, std::tuple<T0, T1> tu)
-    {
-        return Private::TupleHelper<2>::unmarshall(arg, tu);
-    }
-
-    template <class T0, class T1, class T2>
-    const QDBusArgument &operator >>(const QDBusArgument &arg, std::tuple<T0, T1, T2> tu)
-    {
-        return Private::TupleHelper<3>::unmarshall(arg, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3>
-    const QDBusArgument &operator >>(const QDBusArgument &arg, std::tuple<T0, T1, T2, T3> tu)
-    {
-        return Private::TupleHelper<4>::unmarshall(arg, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4>
-    const QDBusArgument &operator >>(const QDBusArgument &arg, std::tuple<T0, T1, T2, T3, T4> tu)
-    {
-        return Private::TupleHelper<5>::unmarshall(arg, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5>
-    const QDBusArgument &operator >>(const QDBusArgument &arg, std::tuple<T0, T1, T2, T3, T4, T5> tu)
-    {
-        return Private::TupleHelper<6>::unmarshall(arg, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
-    const QDBusArgument &operator >>(const QDBusArgument &arg, std::tuple<T0, T1, T2, T3, T4, T5, T6> tu)
-    {
-        return Private::TupleHelper<7>::unmarshall(arg, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-    const QDBusArgument &operator >>(const QDBusArgument &arg, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7> tu)
-    {
-        return Private::TupleHelper<8>::unmarshall(arg, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
-    const QDBusArgument &operator >>(const QDBusArgument &arg, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8> tu)
-    {
-        return Private::TupleHelper<9>::unmarshall(arg, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
-    const QDBusArgument &operator >>(const QDBusArgument &arg, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> tu)
-    {
-        return Private::TupleHelper<10>::unmarshall(arg, tu);
-    }
-
-    inline QDebug operator <<(QDebug debug, std::tuple<> tu)
-    {
-        return Private::TupleHelper<0>::debug(debug, tu);
-    }
-
-    template <class T0>
-    QDebug operator <<(QDebug debug, std::tuple<T0> tu)
-    {
-        return Private::TupleHelper<1>::debug(debug, tu);
-    }
-
-    template <class T0, class T1>
-    QDebug operator <<(QDebug debug, std::tuple<T0, T1> tu)
-    {
-        return Private::TupleHelper<2>::debug(debug, tu);
-    }
-
-    template <class T0, class T1, class T2>
-    QDebug operator <<(QDebug debug, std::tuple<T0, T1, T2> tu)
-    {
-        return Private::TupleHelper<3>::debug(debug, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3>
-    QDebug operator <<(QDebug debug, std::tuple<T0, T1, T2, T3> tu)
-    {
-        return Private::TupleHelper<4>::debug(debug, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4>
-    QDebug operator <<(QDebug debug, std::tuple<T0, T1, T2, T3, T4> tu)
-    {
-        return Private::TupleHelper<5>::debug(debug, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5>
-    QDebug operator <<(QDebug debug, std::tuple<T0, T1, T2, T3, T4, T5> tu)
-    {
-        return Private::TupleHelper<6>::debug(debug, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
-    QDebug operator <<(QDebug debug, std::tuple<T0, T1, T2, T3, T4, T5, T6> tu)
-    {
-        return Private::TupleHelper<7>::debug(debug, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-    QDebug operator <<(QDebug debug, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7> tu)
-    {
-        return Private::TupleHelper<8>::debug(debug, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
-    QDebug operator <<(QDebug debug, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8> tu)
-    {
-        return Private::TupleHelper<9>::debug(debug, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
-    QDebug operator <<(QDebug debug, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> tu)
-    {
-        return Private::TupleHelper<10>::debug(debug, tu);
-    }
-
-    inline QNoDebug operator <<(QNoDebug noDebug, std::tuple<>)
-    {
-        return noDebug;
-    }
-
-    template <class T0>
-    QNoDebug operator <<(QNoDebug noDebug, std::tuple<T0>)
-    {
-        return noDebug;
-    }
-
-    template <class T0, class T1>
-    QNoDebug operator <<(QNoDebug noDebug, std::tuple<T0, T1>)
-    {
-        return noDebug;
-    }
-
-    template <class T0, class T1, class T2>
-    QNoDebug operator <<(QNoDebug noDebug, std::tuple<T0, T1, T2>)
-    {
-        return noDebug;
-    }
-
-    template <class T0, class T1, class T2, class T3>
-    QNoDebug operator <<(QNoDebug noDebug, std::tuple<T0, T1, T2, T3>)
-    {
-        return noDebug;
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4>
-    QNoDebug operator <<(QNoDebug noDebug, std::tuple<T0, T1, T2, T3, T4>)
-    {
-        return noDebug;
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5>
-    QNoDebug operator <<(QNoDebug noDebug, std::tuple<T0, T1, T2, T3, T4, T5>)
-    {
-        return noDebug;
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
-    QNoDebug operator <<(QNoDebug noDebug, std::tuple<T0, T1, T2, T3, T4, T5, T6>)
-    {
-        return noDebug;
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-    QNoDebug operator <<(QNoDebug noDebug, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7>)
-    {
-        return noDebug;
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
-    QNoDebug operator <<(QNoDebug noDebug, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8>)
-    {
-        return noDebug;
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
-    QNoDebug operator <<(QNoDebug noDebug, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>)
-    {
-        return noDebug;
-    }
-
-    inline void deserializeJson(const QJsonObject &json, const QStringList &members, std::tuple<> tu)
-    {
-        Private::TupleHelper<0>::deserializeJson(json, members, tu);
-    }
-
-    template <class T0>
-    void deserializeJson(const QJsonObject &json, const QStringList &members, std::tuple<T0> tu)
-    {
-        Private::TupleHelper<1>::deserializeJson(json, members, tu);
-    }
-
-    template <class T0, class T1>
-    void deserializeJson(const QJsonObject &json, const QStringList &members, std::tuple<T0, T1> tu)
-    {
-        Private::TupleHelper<2>::deserializeJson(json, members, tu);
-    }
-
-    template <class T0, class T1, class T2>
-    void deserializeJson(const QJsonObject &json, const QStringList &members, std::tuple<T0, T1, T2> tu)
-    {
-        Private::TupleHelper<3>::deserializeJson(json, members, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3>
-    void deserializeJson(const QJsonObject &json, const QStringList &members, std::tuple<T0, T1, T2, T3> tu)
-    {
-        Private::TupleHelper<4>::deserializeJson(json, members, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4>
-    void deserializeJson(const QJsonObject &json, const QStringList &members, std::tuple<T0, T1, T2, T3, T4> tu)
-    {
-        Private::TupleHelper<5>::deserializeJson(json, members, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5>
-    void deserializeJson(const QJsonObject &json, const QStringList &members, std::tuple<T0, T1, T2, T3, T4, T5> tu)
-    {
-        Private::TupleHelper<6>::deserializeJson(json, members, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
-    void deserializeJson(const QJsonObject &json, const QStringList &members, std::tuple<T0, T1, T2, T3, T4, T5, T6> tu)
-    {
-        Private::TupleHelper<7>::deserializeJson(json, members, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-    void deserializeJson(const QJsonObject &json, const QStringList &members, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7> tu)
-    {
-        Private::TupleHelper<8>::deserializeJson(json, members, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
-    void deserializeJson(const QJsonObject &json, const QStringList &members, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8> tu)
-    {
-        Private::TupleHelper<9>::deserializeJson(json, members, tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
-    void deserializeJson(const QJsonObject &json, const QStringList &members, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> tu)
-    {
-        Private::TupleHelper<10>::deserializeJson(json, members, tu);
-    }
-
-    inline uint qHash(std::tuple<> tu)
-    {
-        return Private::TupleHelper<0>::hash(tu);
-    }
-
-    template <class T0>
-    uint qHash(std::tuple<T0> tu)
-    {
-        return Private::TupleHelper<1>::hash(tu);
-    }
-
-    template <class T0, class T1>
-    uint qHash(std::tuple<T0, T1> tu)
-    {
-        return Private::TupleHelper<2>::hash(tu);
-    }
-
-    template <class T0, class T1, class T2>
-    uint qHash(std::tuple<T0, T1, T2> tu)
-    {
-        return Private::TupleHelper<3>::hash(tu);
-    }
-
-    template <class T0, class T1, class T2, class T3>
-    uint qHash(std::tuple<T0, T1, T2, T3> tu)
-    {
-        return Private::TupleHelper<4>::hash(tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4>
-    uint qHash(std::tuple<T0, T1, T2, T3, T4> tu)
-    {
-        return Private::TupleHelper<5>::hash(tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5>
-    uint qHash(std::tuple<T0, T1, T2, T3, T4, T5> tu)
-    {
-        return Private::TupleHelper<6>::hash(tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
-    uint qHash(std::tuple<T0, T1, T2, T3, T4, T5, T6> tu)
-    {
-        return Private::TupleHelper<7>::hash(tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-    uint qHash(std::tuple<T0, T1, T2, T3, T4, T5, T6, T7> tu)
-    {
-        return Private::TupleHelper<8>::hash(tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
-    uint qHash(std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8> tu)
-    {
-        return Private::TupleHelper<9>::hash(tu);
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
-    uint qHash(std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> tu)
-    {
-        return Private::TupleHelper<9>::hash(tu);
-    }
-
-    inline QJsonObject serializeJson(const QStringList &members, std::tuple<> tu)
-    {
-        QJsonObject json;
-        Private::TupleHelper<0>::serializeJson(json, members, tu);
-        return json;
-    }
-
-    template <class T0>
-    QJsonObject serializeJson(const QStringList &members, std::tuple<T0> tu)
-    {
-        QJsonObject json;
-        Private::TupleHelper<1>::serializeJson(json, members, tu);
-        return json;
-    }
-
-    template <class T0, class T1>
-    QJsonObject serializeJson(const QStringList &members, std::tuple<T0, T1> tu)
-    {
-        QJsonObject json;
-        Private::TupleHelper<2>::serializeJson(json, members, tu);
-        return json;
-    }
-
-    template <class T0, class T1, class T2>
-    QJsonObject serializeJson(const QStringList &members, std::tuple<T0, T1, T2> tu)
-    {
-        QJsonObject json;
-        Private::TupleHelper<3>::serializeJson(json, members, tu);
-        return json;
-    }
-
-    template <class T0, class T1, class T2, class T3>
-    QJsonObject serializeJson(const QStringList &members, std::tuple<T0, T1, T2, T3> tu)
-    {
-        QJsonObject json;
-        Private::TupleHelper<4>::serializeJson(json, members, tu);
-        return json;
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4>
-    QJsonObject serializeJson(const QStringList &members, std::tuple<T0, T1, T2, T3, T4> tu)
-    {
-        QJsonObject json;
-        Private::TupleHelper<5>::serializeJson(json, members, tu);
-        return json;
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5>
-    QJsonObject serializeJson(const QStringList &members, std::tuple<T0, T1, T2, T3, T4, T5> tu)
-    {
-        QJsonObject json;
-        Private::TupleHelper<6>::serializeJson(json, members, tu);
-        return json;
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
-    QJsonObject serializeJson(const QStringList &members, std::tuple<T0, T1, T2, T3, T4, T5, T6> tu)
-    {
-        QJsonObject json;
-        Private::TupleHelper<7>::serializeJson(json, members, tu);
-        return json;
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-    QJsonObject serializeJson(const QStringList &members, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7> tu)
-    {
-        QJsonObject json;
-        Private::TupleHelper<8>::serializeJson(json, members, tu);
-        return json;
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
-    QJsonObject serializeJson(const QStringList &members, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8> tu)
-    {
-        QJsonObject json;
-        Private::TupleHelper<9>::serializeJson(json, members, tu);
-        return json;
-    }
-
-    template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
-    QJsonObject serializeJson(const QStringList &members, std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> tu)
-    {
-        QJsonObject json;
-        Private::TupleHelper<10>::serializeJson(json, members, tu);
-        return json;
-    }
-
-#endif // Q_COMPILER_VARIADIC_TEMPLATES
-
 } // namespace BlackMisc
 
 #endif // guard
diff --git a/src/blackmisc/tuple_private.h b/src/blackmisc/tuple_private.h
index ef8584f01..ce457353c 100644
--- a/src/blackmisc/tuple_private.h
+++ b/src/blackmisc/tuple_private.h
@@ -30,8 +30,6 @@ namespace BlackMisc
     namespace Private
     {
 
-#ifdef Q_COMPILER_VARIADIC_TEMPLATES
-
         // Helper trait to detect whether a class is a tuple.
         //! \private
         //! @{
@@ -41,35 +39,6 @@ namespace BlackMisc
         struct IsTuple<std::tuple<Ts...>> : public std::true_type {};
         //! @}
 
-#else // !Q_COMPILER_VARIADIC_TEMPLATES
-
-        template <class T>
-        struct IsTuple : public std::false_type {};
-        template <>
-        struct IsTuple<std::tuple<>> : public std::true_type {};
-        template <class T0>
-        struct IsTuple<std::tuple<T0>> : public std::true_type {};
-        template <class T0, class T1>
-        struct IsTuple<std::tuple<T0, T1>> : public std::true_type {};
-        template <class T0, class T1, class T2>
-        struct IsTuple<std::tuple<T0, T1, T2>> : public std::true_type {};
-        template <class T0, class T1, class T2, class T3>
-        struct IsTuple<std::tuple<T0, T1, T2, T3>> : public std::true_type {};
-        template <class T0, class T1, class T2, class T3, class T4>
-        struct IsTuple<std::tuple<T0, T1, T2, T3, T4>> : public std::true_type {};
-        template <class T0, class T1, class T2, class T3, class T4, class T5>
-        struct IsTuple<std::tuple<T0, T1, T2, T3, T4, T5>> : public std::true_type {};
-        template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
-        struct IsTuple<std::tuple<T0, T1, T2, T3, T4, T5, T6>> : public std::true_type {};
-        template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-        struct IsTuple<std::tuple<T0, T1, T2, T3, T4, T5, T6, T7>> : public std::true_type {};
-        template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
-        struct IsTuple<std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8>> : public std::true_type {};
-        template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
-        struct IsTuple<std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>> : public std::true_type {};
-
-#endif // !Q_COMPILER_VARIADIC_TEMPLATES
-
         // Using SFINAE to help detect missing BLACK_ENABLE_TUPLE_CONVERSION macro in static_assert
         //! \private
         std::false_type hasEnabledTupleConversionHelper(...);