Merge pull request #4 from MenloSystems/ExpressionRole-caching

Expression role caching

Author: RaymiiOrg

proxyroles/expressionrole.cpp

@@ -62,22 +62,40 @@ void ExpressionRole::proxyModelCompleted(const QQmlSortFilterProxyModel& proxyMo
     updateContext(proxyModel);
 }
 
-QVariant ExpressionRole::data(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel)
+bool ExpressionRole::isCached() const
 {
-    if (!m_scriptString.isEmpty()) {
-        QVariantMap modelMap;
-        QHash<int, QByteArray> roles = proxyModel.roleNames();
+    return m_cached;
+}
 
-        QQmlContext context(qmlContext(this));
-        auto addToContext = [&] (const QString &name, const QVariant& value) {
-            context.setContextProperty(name, value);
-            modelMap.insert(name, value);
-        };
+void ExpressionRole::setCached(bool cached)
+{
+    if (m_cached == cached) {
+        return;
+    }
+
+    m_cached = cached;
+    emit cachedChanged(m_cached);
+}
+
+void ExpressionRole::invalidateCache()
+{
+    m_cache.clear();
+}
 
-        for (auto it = roles.cbegin(); it != roles.cend(); ++it)
-            addToContext(it.value(), proxyModel.sourceData(sourceIndex, it.key()));
-        addToContext("index", sourceIndex.row());
+QVariant ExpressionRole::data(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel)
+{
+    if (isCached()) {
+        const auto it = m_cache.constFind(sourceIndex);
+        if (it != m_cache.constEnd()) {
+            return *it;
+        }
+    }
 
+    if (!m_scriptString.isEmpty()) {
+        const QVariant modelMap = proxyModel.sourceData(sourceIndex);
+        QQmlContext context(qmlContext(this));
+        context.setContextProperty("index", sourceIndex.row());
+        context.setContextProperty("modelIndex", sourceIndex);
         context.setContextProperty("model", modelMap);
 
         QQmlExpression expression(m_scriptString, &context);
@@ -87,6 +105,11 @@ QVariant ExpressionRole::data(const QModelIndex& sourceIndex, const QQmlSortFilt
             qWarning() << expression.error();
             return true;
         }
+
+        if (isCached()) {
+            m_cache[sourceIndex] = result;
+        }
+
         return result;
     }
     return QVariant();
@@ -99,16 +122,13 @@ void ExpressionRole::updateContext(const QQmlSortFilterProxyModel& proxyModel)
     // what about roles changes ?
     QVariantMap modelMap;
 
-    auto addToContext = [&] (const QString &name, const QVariant& value) {
-        m_context->setContextProperty(name, value);
-        modelMap.insert(name, value);
-    };
-
-    for (const QByteArray& roleName : proxyModel.roleNames().values())
-        addToContext(roleName, QVariant());
-
-    addToContext("index", -1);
+    const auto roleNames = proxyModel.roleNames().values();
+    for (const QByteArray& roleName : roleNames) {
+        modelMap[roleName] = QVariant();
+    }
 
+    m_context->setContextProperty("index", -1);
+    m_context->setContextProperty("modelIndex", QModelIndex());
     m_context->setContextProperty("model", modelMap);
     updateExpression();
 }
@@ -120,7 +140,10 @@ void ExpressionRole::updateExpression()
 
     delete m_expression;
     m_expression = new QQmlExpression(m_scriptString, m_context, 0, this);
-    connect(m_expression, &QQmlExpression::valueChanged, this, &ExpressionRole::invalidate);
+    connect(m_expression, &QQmlExpression::valueChanged, this, [=] {
+        invalidateCache();
+        invalidate();
+    });
     m_expression->setNotifyOnValueChanged(true);
     m_expression->evaluate();
 }

proxyroles/expressionrole.h

@@ -2,6 +2,8 @@
 #define EXPRESSIONROLE_H
 
 #include "singlerole.h"
+#include <QMap>
+#include <QPersistentModelIndex>
 #include <QQmlScriptString>
 
 class QQmlExpression;
@@ -12,17 +14,24 @@ class ExpressionRole : public SingleRole
 {
     Q_OBJECT
     Q_PROPERTY(QQmlScriptString expression READ expression WRITE setExpression NOTIFY expressionChanged)
+    Q_PROPERTY(bool cached READ isCached WRITE setCached NOTIFY cachedChanged)
 
 public:
     using SingleRole::SingleRole;
 
     const QQmlScriptString& expression() const;
     void setExpression(const QQmlScriptString& scriptString);
+    bool isCached() const;
 
     void proxyModelCompleted(const QQmlSortFilterProxyModel& proxyModel) override;
 
+public slots:
+    void setCached(bool cached);
+    void invalidateCache();
+
 Q_SIGNALS:
     void expressionChanged();
+    void cachedChanged(bool cached);
 
 private:
     QVariant data(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) override;
@@ -32,6 +41,9 @@ class ExpressionRole : public SingleRole
     QQmlScriptString m_scriptString;
     QQmlExpression* m_expression = nullptr;
     QQmlContext* m_context = nullptr;
+
+    QHash<QPersistentModelIndex, QVariant> m_cache;
+    bool m_cached = false;
 };
 
 }