From 9d1f8a63f3a564841a4c38318cfa624d88b9ce53 Mon Sep 17 00:00:00 2001
From: Klaus Basan <klaus.basan@klausbasan.de>
Date: Wed, 26 Mar 2014 18:02:36 +0100
Subject: [PATCH] refs #192 , added JSON support to tupel * jsonMembers()
 method in Macro * serializeJson / deserializeJson for tupels

---
 src/blackmisc/tuple.h         | 340 +++++++++++++++++++++++++++++++---
 src/blackmisc/tuple_private.h |  54 ++++--
 2 files changed, 359 insertions(+), 35 deletions(-)

diff --git a/src/blackmisc/tuple.h b/src/blackmisc/tuple.h
index a5bd2d373..21f84687e 100644
--- a/src/blackmisc/tuple.h
+++ b/src/blackmisc/tuple.h
@@ -11,6 +11,7 @@
 #define BLACKMISC_TUPLE_H
 
 #include "tuple_private.h"
+#include "json.h"
 
 /*!
  * \defgroup Tuples Tuples Simplified handling of class members (CValueObject) by std::tuple
@@ -49,7 +50,7 @@
         {                                                                       \
             friend class T;                                                     \
             static_assert(Private::HasEnabledTupleConversion<T>::type::value,   \
-                "Missing BLACK_ENABLE_TUPLE_CONVERSION macro in " #T);          \
+                          "Missing BLACK_ENABLE_TUPLE_CONVERSION macro in " #T); \
             static auto toTuple(const T &o) -> decltype(std::tie MEMBERS)       \
             {                                                                   \
                 return std::tie MEMBERS;                                        \
@@ -58,6 +59,11 @@
             {                                                                   \
                 return std::tie MEMBERS;                                        \
             }                                                                   \
+            static const QStringList &jsonMembers()                             \
+            {                                                                   \
+                static QStringList members = QString(#MEMBERS).replace("(","").replace(")","").replace(" ","").replace("o.","").split(","); \
+                return members;                                                 \
+            }                                                                   \
         };                                                                      \
     }
 
@@ -73,7 +79,7 @@
         {                                                                       \
             friend class T<U>;                                                  \
             static_assert(Private::HasEnabledTupleConversion<T<U>>::type::value,\
-                "Missing BLACK_ENABLE_TUPLE_CONVERSION macro in " #T);          \
+                          "Missing BLACK_ENABLE_TUPLE_CONVERSION macro in " #T);          \
             static auto toTuple(const T<U> &o) -> decltype(std::tie MEMBERS)    \
             {                                                                   \
                 return std::tie MEMBERS;                                        \
@@ -82,6 +88,11 @@
             {                                                                   \
                 return std::tie MEMBERS;                                        \
             }                                                                   \
+            static const QStringList &jsonMembers()                             \
+            {                                                                   \
+                static QStringList members = QString(#MEMBERS).replace("(","").replace(")","").replace(" ","").replace("o.","").split(","); \
+                return members;                                                 \
+            }                                                                   \
         };                                                                      \
     }
 
@@ -113,17 +124,31 @@ namespace BlackMisc
         static std::tuple<> toTuple(const T &object)
         {
             static_assert(std::is_void<T>::value, // always false; is_void<> trick is just to make the condition dependent on the template parameter T
-                "Missing BLACK_DECLARE_TUPLE_CONVERSION macro for T");
+                          "Missing BLACK_DECLARE_TUPLE_CONVERSION macro for T");
             Q_UNUSED(object);
             return std::tuple<>();
         }
         static std::tuple<> toTuple(T &object)
         {
             static_assert(std::is_void<T>::value, // always false; is_void<> trick is just to make the condition dependent on the template parameter T
-                "Missing BLACK_DECLARE_TUPLE_CONVERSION macro for T");
+                          "Missing BLACK_DECLARE_TUPLE_CONVERSION macro for T");
             Q_UNUSED(object);
             return std::tuple<>();
         }
+        static const QStringList members()
+        {
+            static_assert(std::is_void<T>::value, // always false; is_void<> trick is just to make the condition dependent on the template parameter T
+                          "Missing BLACK_DECLARE_TUPLE_CONVERSION macro for T");
+            static QStringList members;
+            return members;
+        }
+        static const QStringList jsonMembers()
+        {
+            static_assert(std::is_void<T>::value, // always false; is_void<> trick is just to make the condition dependent on the template parameter T
+                          "Missing BLACK_DECLARE_TUPLE_CONVERSION macro for T");
+            static QStringList members;
+            return members;
+        }
         //! @}
     };
 
@@ -176,6 +201,29 @@ namespace BlackMisc
         return Private::TupleHelper<sizeof...(Ts)>::hash(tu);
     }
 
+    /*!
+     * \brief   Convert to a JSON object
+     * \ingroup Tupels
+     */
+    template <class... Ts>
+    QJsonObject serializeJson(const QStringList &members, std::tuple<const Ts &...> tu)
+    {
+        QJsonObject json;
+        Private::TupleHelper<sizeof...(Ts)>::serializeJson(json, members, tu);
+        return json;
+    }
+
+    /*!
+     * Convert from JSON to object
+     * \ingroup Tupels
+     */
+    template <class... Ts>
+    void deserializeJson(const QJsonObject &json, const QStringList &members, std::tuple<Ts &...> tu)
+    {
+        Private::TupleHelper<sizeof...(Ts)>::deserializeJson(json, members, tu);
+    }
+
+
 #else // !Q_COMPILER_VARIADIC_TEMPLATES
 
     inline int compare(std::tuple<>, std::tuple<>)
@@ -336,35 +384,35 @@ namespace BlackMisc
     QDBusArgument &operator <<(QDBusArgument &arg, std::tuple<T0 &, T1 &, T2 &, T3 &, T4 &, T5 &> tu)
     {
         return arg << std::get<0>(tu) << std::get<1>(tu) << std::get<2>(tu) << std::get<3>(tu) << std::get<4>(tu)
-                   << std::get<5>(tu);
+               << std::get<5>(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 arg << std::get<0>(tu) << std::get<1>(tu) << std::get<2>(tu) << std::get<3>(tu) << std::get<4>(tu)
-                   << std::get<5>(tu) << std::get<6>(tu);
+               << std::get<5>(tu) << std::get<6>(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 arg << std::get<0>(tu) << std::get<1>(tu) << std::get<2>(tu) << std::get<3>(tu) << std::get<4>(tu)
-                   << std::get<5>(tu) << std::get<6>(tu) << std::get<7>(tu);
+               << std::get<5>(tu) << std::get<6>(tu) << std::get<7>(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 arg << std::get<0>(tu) << std::get<1>(tu) << std::get<2>(tu) << std::get<3>(tu) << std::get<4>(tu)
-                   << std::get<5>(tu) << std::get<6>(tu) << std::get<7>(tu) << std::get<8>(tu);
+                << std::get<5>(tu) << std::get<6>(tu) << std::get<7>(tu) << std::get<8>(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 arg << std::get<0>(tu) << std::get<1>(tu) << std::get<2>(tu) << std::get<3>(tu) << std::get<4>(tu)
-                   << std::get<5>(tu) << std::get<6>(tu) << std::get<7>(tu) << std::get<8>(tu) << std::get<9>(tu);
+               << std::get<5>(tu) << std::get<6>(tu) << std::get<7>(tu) << std::get<8>(tu) << std::get<9>(tu);
     }
 
     inline const QDBusArgument &operator >>(const QDBusArgument &arg, std::tuple<>)
@@ -406,35 +454,147 @@ namespace BlackMisc
     const QDBusArgument &operator >>(const QDBusArgument &arg, std::tuple<T0 &, T1 &, T2 &, T3 &, T4 &, T5 &> tu)
     {
         return arg >> std::get<0>(tu) >> std::get<1>(tu) >> std::get<2>(tu) >> std::get<3>(tu) >> std::get<4>(tu)
-                   >> std::get<5>(tu);
+               >> std::get<5>(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 arg >> std::get<0>(tu) >> std::get<1>(tu) >> std::get<2>(tu) >> std::get<3>(tu) >> std::get<4>(tu)
-                   >> std::get<5>(tu) >> std::get<6>(tu);
+               >> std::get<5>(tu) >> std::get<6>(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 arg >> std::get<0>(tu) >> std::get<1>(tu) >> std::get<2>(tu) >> std::get<3>(tu) >> std::get<4>(tu)
-                   >> std::get<5>(tu) >> std::get<6>(tu) >> std::get<7>(tu);
+               >> std::get<5>(tu) >> std::get<6>(tu) >> std::get<7>(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 arg >> std::get<0>(tu) >> std::get<1>(tu) >> std::get<2>(tu) >> std::get<3>(tu) >> std::get<4>(tu)
-                   >> std::get<5>(tu) >> std::get<6>(tu) >> std::get<7>(tu) >> std::get<8>(tu);
+               >> std::get<5>(tu) >> std::get<6>(tu) >> std::get<7>(tu) >> std::get<8>(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 arg >> std::get<0>(tu) >> std::get<1>(tu) >> std::get<2>(tu) >> std::get<3>(tu) >> std::get<4>(tu)
-                   >> std::get<5>(tu) >> std::get<6>(tu) >> std::get<7>(tu) >> std::get<8>(tu) >> std::get<9>(tu);
+               >> std::get<5>(tu) >> std::get<6>(tu) >> std::get<7>(tu) >> std::get<8>(tu) >> std::get<9>(tu);
+    }
+
+    inline void deserializeJson(const QJsonObject &json, const QStringList &members, std::tuple<> tu)
+    {
+        Q_UNUSED(json);
+        Q_UNUSED(members);
+        Q_UNUSED(tu);
+    }
+
+    template <class T0>
+    void deserializeJson(const QJsonObject &json, const QStringList &members, std::tuple<T0 &> tu)
+    {
+        json.value(members.at(0)) >> std::get<0>(tu);
+    }
+
+    template <class T0, class T1>
+    void deserializeJson(const QJsonObject &json, const QStringList &members, std::tuple<T0 &, T1 &> tu)
+    {
+        json.value(members.at(0)) >> std::get<0>(tu);
+        json.value(members.at(1)) >> std::get<1>(tu);
+    }
+
+    template <class T0, class T1, class T2>
+    void deserializeJson(const QJsonObject &json, const QStringList &members, std::tuple<T0 &, T1 &, T2 &> tu)
+    {
+        json.value(members.at(0)) >> std::get<0>(tu);
+        json.value(members.at(1)) >> std::get<1>(tu);
+        json.value(members.at(2)) >> std::get<2>(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)
+    {
+        json.value(members.at(0)) >> std::get<0>(tu);
+        json.value(members.at(1)) >> std::get<1>(tu);
+        json.value(members.at(2)) >> std::get<2>(tu);
+        json.value(members.at(3)) >> std::get<3>(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)
+    {
+        json.value(members.at(0)) >> std::get<0>(tu);
+        json.value(members.at(1)) >> std::get<1>(tu);
+        json.value(members.at(2)) >> std::get<2>(tu);
+        json.value(members.at(3)) >> std::get<3>(tu);
+        json.value(members.at(4)) >> std::get<4>(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)
+    {
+        json.value(members.at(0)) >> std::get<0>(tu);
+        json.value(members.at(1)) >> std::get<1>(tu);
+        json.value(members.at(2)) >> std::get<2>(tu);
+        json.value(members.at(3)) >> std::get<3>(tu);
+        json.value(members.at(4)) >> std::get<4>(tu);
+        json.value(members.at(5)) >> std::get<5>(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)
+    {
+        json.value(members.at(0)) >> std::get<0>(tu);
+        json.value(members.at(1)) >> std::get<1>(tu);
+        json.value(members.at(2)) >> std::get<2>(tu);
+        json.value(members.at(3)) >> std::get<3>(tu);
+        json.value(members.at(4)) >> std::get<4>(tu);
+        json.value(members.at(5)) >> std::get<5>(tu);
+        json.value(members.at(6)) >> std::get<6>(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)
+    {
+        json.value(members.at(0)) >> std::get<0>(tu);
+        json.value(members.at(1)) >> std::get<1>(tu);
+        json.value(members.at(2)) >> std::get<2>(tu);
+        json.value(members.at(3)) >> std::get<3>(tu);
+        json.value(members.at(4)) >> std::get<4>(tu);
+        json.value(members.at(5)) >> std::get<5>(tu);
+        json.value(members.at(6)) >> std::get<6>(tu);
+        json.value(members.at(7)) >> std::get<7>(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)
+    {
+        json.value(members.at(0)) >> std::get<0>(tu);
+        json.value(members.at(1)) >> std::get<1>(tu);
+        json.value(members.at(2)) >> std::get<2>(tu);
+        json.value(members.at(3)) >> std::get<3>(tu);
+        json.value(members.at(4)) >> std::get<4>(tu);
+        json.value(members.at(5)) >> std::get<5>(tu);
+        json.value(members.at(6)) >> std::get<6>(tu);
+        json.value(members.at(7)) >> std::get<7>(tu);
+        json.value(members.at(8)) >> std::get<8>(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)
+    {
+        json.value(members.at(0)) >> std::get<0>(tu);
+        json.value(members.at(1)) >> std::get<1>(tu);
+        json.value(members.at(2)) >> std::get<2>(tu);
+        json.value(members.at(3)) >> std::get<3>(tu);
+        json.value(members.at(4)) >> std::get<4>(tu);
+        json.value(members.at(5)) >> std::get<5>(tu);
+        json.value(members.at(6)) >> std::get<6>(tu);
+        json.value(members.at(7)) >> std::get<7>(tu);
+        json.value(members.at(8)) >> std::get<8>(tu);
+        json.value(members.at(9)) >> std::get<9>(tu);
     }
 
     inline uint qHash(std::tuple<>)
@@ -475,36 +635,168 @@ namespace BlackMisc
     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 qHash(std::get<0>(tu)) ^ qHash(std::get<1>(tu)) ^ qHash(std::get<2>(tu)) ^ qHash(std::get<3>(tu)) ^ qHash(std::get<4>(tu))
-             ^ qHash(std::get<5>(tu));
+        return qHash(std::get<0>(tu)) ^ qHash(std::get<1>(tu)) ^ qHash(std::get<2>(tu)) ^ qHash(std::get<3>(tu)) ^ qHash(std::get<4>(tu)) ^
+               qHash(std::get<5>(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 qHash(std::get<0>(tu)) ^ qHash(std::get<1>(tu)) ^ qHash(std::get<2>(tu)) ^ qHash(std::get<3>(tu)) ^ qHash(std::get<4>(tu))
-             ^ qHash(std::get<5>(tu)) ^ qHash(std::get<6>(tu));
+        return qHash(std::get<0>(tu)) ^ qHash(std::get<1>(tu)) ^ qHash(std::get<2>(tu)) ^ qHash(std::get<3>(tu)) ^ qHash(std::get<4>(tu)) ^
+               qHash(std::get<5>(tu)) ^ qHash(std::get<6>(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 qHash(std::get<0>(tu)) ^ qHash(std::get<1>(tu)) ^ qHash(std::get<2>(tu)) ^ qHash(std::get<3>(tu)) ^ qHash(std::get<4>(tu))
-             ^ qHash(std::get<5>(tu)) ^ qHash(std::get<6>(tu)) ^ qHash(std::get<7>(tu));
+        return qHash(std::get<0>(tu)) ^ qHash(std::get<1>(tu)) ^ qHash(std::get<2>(tu)) ^ qHash(std::get<3>(tu)) ^ qHash(std::get<4>(tu)) ^
+               qHash(std::get<5>(tu)) ^ qHash(std::get<6>(tu)) ^ qHash(std::get<7>(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 qHash(std::get<0>(tu)) ^ qHash(std::get<1>(tu)) ^ qHash(std::get<2>(tu)) ^ qHash(std::get<3>(tu)) ^ qHash(std::get<4>(tu))
-             ^ qHash(std::get<5>(tu)) ^ qHash(std::get<6>(tu)) ^ qHash(std::get<7>(tu)) ^ qHash(std::get<8>(tu));
+        return qHash(std::get<0>(tu)) ^ qHash(std::get<1>(tu)) ^ qHash(std::get<2>(tu)) ^ qHash(std::get<3>(tu)) ^ qHash(std::get<4>(tu)) ^
+               qHash(std::get<5>(tu)) ^ qHash(std::get<6>(tu)) ^ qHash(std::get<7>(tu)) ^ qHash(std::get<8>(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 qHash(std::get<0>(tu)) ^ qHash(std::get<1>(tu)) ^ qHash(std::get<2>(tu)) ^ qHash(std::get<3>(tu)) ^ qHash(std::get<4>(tu))
-             ^ qHash(std::get<5>(tu)) ^ qHash(std::get<6>(tu)) ^ qHash(std::get<7>(tu)) ^ qHash(std::get<8>(tu)) ^ qHash(std::get<9>(tu));
+        return qHash(std::get<0>(tu)) ^ qHash(std::get<1>(tu)) ^ qHash(std::get<2>(tu)) ^ qHash(std::get<3>(tu)) ^ qHash(std::get<4>(tu)) ^
+               qHash(std::get<5>(tu)) ^ qHash(std::get<6>(tu)) ^ qHash(std::get<7>(tu)) ^ qHash(std::get<8>(tu)) ^ qHash(std::get<9>(tu));
+    }
+
+    inline QJsonObject serializeJson(const QStringList &members, std::tuple<>)
+    {
+        Q_UNUSED(members);
+        QJsonObject json;
+        return json;
+    }
+
+    template <class T0>
+    QJsonObject serializeJson(const QStringList &members, std::tuple<const T0 &> tu)
+    {
+        QJsonObject json;
+        json << std::pair<QString, T0>(members.at(0), std::get<0>(tu));
+        return json;
+    }
+
+    template <class T0, class T1>
+    QJsonObject serializeJson(const QStringList &members, std::tuple<const T0 &, const T1 &> tu)
+    {
+        QJsonObject json;
+        json << std::pair<QString, T0>(members.at(0), std::get<0>(tu));
+        json << std::pair<QString, T1>(members.at(1), std::get<1>(tu));
+        return json;
+    }
+
+    template <class T0, class T1, class T2>
+    QJsonObject serializeJson(const QStringList &members, std::tuple<const T0 &, const T1 &, const T2 &> tu)
+    {
+        QJsonObject json;
+        json << std::pair<QString, T0>(members.at(0), std::get<0>(tu));
+        json << std::pair<QString, T1>(members.at(1), std::get<1>(tu));
+        json << std::pair<QString, T2>(members.at(2), std::get<2>(tu));
+        return json;
+    }
+
+    template <class T0, class T1, class T2, class T3>
+    QJsonObject serializeJson(const QStringList &members, std::tuple<const T0 &, const T1 &, const T2 &, const T3 &> tu)
+    {
+        QJsonObject json;
+        json << std::pair<QString, T0>(members.at(0), std::get<0>(tu));
+        json << std::pair<QString, T1>(members.at(1), std::get<1>(tu));
+        json << std::pair<QString, T2>(members.at(2), std::get<2>(tu));
+        json << std::pair<QString, T3>(members.at(3), std::get<3>(tu));
+        return json;
+    }
+
+    template <class T0, class T1, class T2, class T3, class T4>
+    QJsonObject serializeJson(const QStringList &members, std::tuple<const T0 &, const T1 &, const T2 &, const T3 &, const T4 &> tu)
+    {
+        QJsonObject json;
+        json << std::pair<QString, T0>(members.at(0), std::get<0>(tu));
+        json << std::pair<QString, T1>(members.at(1), std::get<1>(tu));
+        json << std::pair<QString, T2>(members.at(2), std::get<2>(tu));
+        json << std::pair<QString, T3>(members.at(3), std::get<3>(tu));
+        json << std::pair<QString, T4>(members.at(4), std::get<4>(tu));
+        return json;
+    }
+
+    template <class T0, class T1, class T2, class T3, class T4, class T5>
+    QJsonObject serializeJson(const QStringList &members, std::tuple<const T0 &, const T1 &, const T2 &, const T3 &, const T4 &, const T5 &> tu)
+    {
+        QJsonObject json;
+        json << std::pair<QString, T0>(members.at(0), std::get<0>(tu));
+        json << std::pair<QString, T1>(members.at(1), std::get<1>(tu));
+        json << std::pair<QString, T2>(members.at(2), std::get<2>(tu));
+        json << std::pair<QString, T3>(members.at(3), std::get<3>(tu));
+        json << std::pair<QString, T4>(members.at(4), std::get<4>(tu));
+        json << std::pair<QString, T5>(members.at(5), std::get<5>(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<const T0 &, const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &> tu)
+    {
+        QJsonObject json;
+        json << std::pair<QString, T0>(members.at(0), std::get<0>(tu));
+        json << std::pair<QString, T1>(members.at(1), std::get<1>(tu));
+        json << std::pair<QString, T2>(members.at(2), std::get<2>(tu));
+        json << std::pair<QString, T3>(members.at(3), std::get<3>(tu));
+        json << std::pair<QString, T4>(members.at(4), std::get<4>(tu));
+        json << std::pair<QString, T5>(members.at(5), std::get<5>(tu));
+        json << std::pair<QString, T6>(members.at(6), std::get<6>(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<const T0 &, const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &> tu)
+    {
+        QJsonObject json;
+        json << std::pair<QString, T0>(members.at(0), std::get<0>(tu));
+        json << std::pair<QString, T1>(members.at(1), std::get<1>(tu));
+        json << std::pair<QString, T2>(members.at(2), std::get<2>(tu));
+        json << std::pair<QString, T3>(members.at(3), std::get<3>(tu));
+        json << std::pair<QString, T4>(members.at(4), std::get<4>(tu));
+        json << std::pair<QString, T5>(members.at(5), std::get<5>(tu));
+        json << std::pair<QString, T6>(members.at(6), std::get<6>(tu));
+        json << std::pair<QString, T7>(members.at(7), std::get<7>(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<const T0 &, const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &, const T8 &> tu)
+    {
+        QJsonObject json;
+        json << std::pair<QString, T0>(members.at(0), std::get<0>(tu));
+        json << std::pair<QString, T1>(members.at(1), std::get<1>(tu));
+        json << std::pair<QString, T2>(members.at(2), std::get<2>(tu));
+        json << std::pair<QString, T3>(members.at(3), std::get<3>(tu));
+        json << std::pair<QString, T4>(members.at(4), std::get<4>(tu));
+        json << std::pair<QString, T5>(members.at(5), std::get<5>(tu));
+        json << std::pair<QString, T6>(members.at(6), std::get<6>(tu));
+        json << std::pair<QString, T7>(members.at(7), std::get<7>(tu));
+        json << std::pair<QString, T8>(members.at(8), std::get<8>(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<const T0 &, const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &, const T8 &, const T9 &> tu)
+    {
+        QJsonObject json;
+        json << std::pair<QString, T0>(members.at(0), std::get<0>(tu));
+        json << std::pair<QString, T1>(members.at(1), std::get<1>(tu));
+        json << std::pair<QString, T2>(members.at(2), std::get<2>(tu));
+        json << std::pair<QString, T3>(members.at(3), std::get<3>(tu));
+        json << std::pair<QString, T4>(members.at(4), std::get<4>(tu));
+        json << std::pair<QString, T5>(members.at(5), std::get<5>(tu));
+        json << std::pair<QString, T6>(members.at(6), std::get<6>(tu));
+        json << std::pair<QString, T7>(members.at(7), std::get<7>(tu));
+        json << std::pair<QString, T8>(members.at(8), std::get<8>(tu));
+        json << std::pair<QString, T9>(members.at(9), std::get<9>(tu));
+        return json;
     }
 
 #endif // Q_COMPILER_VARIADIC_TEMPLATES
diff --git a/src/blackmisc/tuple_private.h b/src/blackmisc/tuple_private.h
index 7a911e0cd..2b7a01816 100644
--- a/src/blackmisc/tuple_private.h
+++ b/src/blackmisc/tuple_private.h
@@ -11,15 +11,17 @@
 #ifndef BLACKMISC_TUPLE_PRIVATE_H
 #define BLACKMISC_TUPLE_PRIVATE_H
 
+#include "json.h"
 #include <QtGlobal>
 #include <QDBusArgument>
 #include <QHash>
+#include <QJsonObject>
+#include <QDateTime>
 #include <tuple>
 #include <type_traits>
 
 namespace BlackMisc
 {
-
     class CValueObject;
 
     namespace Private
@@ -62,11 +64,11 @@ namespace BlackMisc
         template <int N, class Tu>
         int compareHelper(const Tu &a, const Tu &b)
         {
-            typedef typename std::is_base_of<
-                CValueObject,
-                typename std::decay<
-                    typename std::tuple_element<N, Tu>::type
-                >::type
+            typedef typename std::is_base_of <
+            CValueObject,
+            typename std::decay <
+            typename std::tuple_element<N, Tu>::type
+            >::type
             >::type isCValueObjectTag;
 
             return compareHelper(std::get<N>(a), std::get<N>(b), isCValueObjectTag());
@@ -83,27 +85,43 @@ namespace BlackMisc
             template <class Tu>
             static int compare(const Tu &a, const Tu &b)
             {
-                const int head = TupleHelper<N - 1>::compare(a, b);
+                const int head = TupleHelper < N - 1 >::compare(a, b);
                 if (head) { return head; }
-                return compareHelper<N - 1>(a, b);
+                return compareHelper < N - 1 > (a, b);
             }
 
             template <class Tu>
             static QDBusArgument &marshall(QDBusArgument &arg, const Tu &tu)
             {
-                return TupleHelper<N - 1>::marshall(arg, tu) << std::get<N - 1>(tu);
+                return TupleHelper < N - 1 >::marshall(arg, tu) << std::get < N - 1 > (tu);
             }
 
             template <class Tu>
             static const QDBusArgument &unmarshall(const QDBusArgument &arg, Tu &tu)
             {
-                return TupleHelper<N - 1>::unmarshall(arg, tu) >> std::get<N - 1>(tu);
+                return TupleHelper < N - 1 >::unmarshall(arg, tu) >> std::get < N - 1 > (tu);
             }
 
             template <class Tu>
             static uint hash(const Tu &tu)
             {
-                return TupleHelper<N - 1>::hash(tu) ^ qHash(std::get<N - 1>(tu));
+                return TupleHelper < N - 1 >::hash(tu) ^ qHash(std::get < N - 1 > (tu));
+            }
+
+            template <class Tu>
+            static void serializeJson(QJsonObject &json, const QStringList &members, const Tu &tu)
+            {
+                // typedef typename std::remove_const < typename std::remove_reference < typename std::tuple_element < N - 1, Tu >::type >::type >::type TARGET;
+                typedef typename std::decay < typename std::tuple_element < N - 1, Tu >::type >::type TARGET;
+                json << std::pair<QString, TARGET>(members.at(N - 1), std::get < N - 1 > (tu));
+                TupleHelper < N - 1 >::serializeJson(json, members, tu);
+            }
+
+            template <class Tu>
+            static void deserializeJson(const QJsonObject &json, const QStringList &members, Tu &tu)
+            {
+                json.value(members.at(N - 1)) >> std::get < N - 1 > (tu);
+                TupleHelper < N - 1 >::deserializeJson(json, members, tu);
             }
         };
 
@@ -119,6 +137,20 @@ namespace BlackMisc
             static const QDBusArgument &unmarshall(const QDBusArgument &arg, Tu &) { return arg; }
             template <class Tu>
             static uint hash(const Tu &) { return 0; }
+            template <class Tu>
+            static void serializeJson(QJsonObject &json, const QStringList &members, const Tu &tu)
+            {
+                Q_UNUSED(json);
+                Q_UNUSED(members);
+                Q_UNUSED(tu);
+            }
+            template <class Tu>
+            static void deserializeJson(const QJsonObject &json, const QStringList &members, Tu &tu)
+            {
+                Q_UNUSED(json);
+                Q_UNUSED(members);
+                Q_UNUSED(tu);
+            }
         };
 
 #endif // Q_COMPILER_VARIADIC_TEMPLATES