flightsimulatorplatfrom/pilotclient
1
0
Fork 0
mirror of https://github.com/swift-project/pilotclient.git synced 2026-03-31 04:25:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

refs #245 removed fake variadics for tuples and predicates

Browse Source
This commit is contained in:
Mathew Sutcliffe
2014-06-05 23:57:07 +01:00
parent c8bf23bf86
commit 05fd6fbcae
3 changed files with 0 additions and 716 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
src/blackmisc/predicates.h
View File

@@ -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

629
src/blackmisc/tuple.h
View File

@@ -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

31
src/blackmisc/tuple_private.h
View File

@@ -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(...);