PersistentPool: Replace {store,load}QVariantMap with generic version

That one can also be used to store other QMaps as well as QHashes.

Change-Id: Icb71c7ef293d115ea2518ddd9e16d094fb91625e
Reviewed-by: Joerg Bornemann <joerg.bornemann@qt.io>

2 files changed, 30 insertions, 32 deletions

diff --git a/src/lib/corelib/tools/persistence.cpp b/src/lib/corelib/tools/persistence.cpp
index 140766145..116a689dd 100644
--- a/src/lib/corelib/tools/persistence.cpp
+++ b/src/lib/corelib/tools/persistence.cpp
@@ -158,28 +158,6 @@ void PersistentPool::storePersistentObject(const PersistentObject *object)
     }
 }
 
-void PersistentPool::storeVariantMap(const QVariantMap &map)
-{
-    m_stream << map.count();
-    for (QVariantMap::ConstIterator it = map.constBegin(); it != map.constEnd(); ++it) {
-        storeString(it.key());
-        store(it.value());
-    }
-}
-
-QVariantMap PersistentPool::loadVariantMap()
-{
-    int count;
-    m_stream >> count;
-    QVariantMap map;
-    for (int i = 0; i < count; ++i) {
-        const QString key = idLoadString();
-        const QVariant value = loadVariant();
-        map.insert(key, value);
-    }
-    return map;
-}
-
 void PersistentPool::storeVariant(const QVariant &variant)
 {
     const quint32 type = static_cast<quint32>(variant.type());
@@ -224,7 +202,7 @@ QVariant PersistentPool::loadVariant()
         break;
     }
     case QMetaType::QVariantMap:
-        value = loadVariantMap();
+        value = load<QVariantMap>();
         break;
     default:
         m_stream >> value;
diff --git a/src/lib/corelib/tools/persistence.h b/src/lib/corelib/tools/persistence.h
index 25529ccf7..f1bfd439d 100644
--- a/src/lib/corelib/tools/persistence.h
+++ b/src/lib/corelib/tools/persistence.h
@@ -98,9 +98,6 @@ private:
 
     void storePersistentObject(const PersistentObject *object);
 
-    void storeVariantMap(const QVariantMap &map);
-    QVariantMap loadVariantMap();
-
     void storeVariant(const QVariant &variant);
     QVariant loadVariant();
 
@@ -223,12 +220,6 @@ template<> struct PersistentPool::Helper<QVariant>
     static void load(QVariant &v, PersistentPool *pool) { v = pool->loadVariant(); }
 };
 
-template<> struct PersistentPool::Helper<QVariantMap>
-{
-    static void store(const QVariantMap &map, PersistentPool *pool) { pool->storeVariantMap(map); }
-    static void load(QVariantMap &map, PersistentPool *pool) { map = pool->loadVariantMap(); }
-};
-
 class ArtifactSet;
 template<typename T> struct IsSimpleContainer { static const bool value = false; };
 template<> struct IsSimpleContainer<ArtifactSet> { static const bool value = true; };
@@ -256,6 +247,35 @@ struct PersistentPool::Helper<T, typename std::enable_if<IsSimpleContainer<T>::v
     }
 };
 
+template<typename T> struct IsKeyValueContainer { static const bool value = false; };
+template<typename K, typename V> struct IsKeyValueContainer<QMap<K, V>>
+{
+    static const bool value = true;
+};
+
+template<typename T>
+struct PersistentPool::Helper<T, typename std::enable_if<IsKeyValueContainer<T>::value>::type>
+{
+    static void store(const T &container, PersistentPool *pool)
+    {
+        pool->stream() << container.count();
+        for (auto it = container.cbegin(); it != container.cend(); ++it) {
+            pool->store(it.key());
+            pool->store(it.value());
+        }
+    }
+    static void load(T &container, PersistentPool *pool)
+    {
+        container.clear();
+        const int count = pool->load<int>();
+        for (int i = 0; i < count; ++i) {
+            const auto &key = pool->load<typename T::key_type>();
+            const auto &value = pool->load<typename T::mapped_type>();
+            container.insert(key, value);
+        }
+    }
+};
+
 } // namespace Internal
 } // namespace qbs