Use meta property cache for property restores

3 files changed, 84 insertions, 36 deletions

diff --git a/src/declarative/qml/qmlengine_p.h b/src/declarative/qml/qmlengine_p.h
index dffae6c..602321d 100644
--- a/src/declarative/qml/qmlengine_p.h
+++ b/src/declarative/qml/qmlengine_p.h
@@ -179,6 +179,10 @@ public:
 
     QmlValueTypeFactory valueTypes;
     QHash<const QMetaObject *, QmlMetaObjectCache> propertyCache;
+    static QmlMetaObjectCache *cache(QmlEnginePrivate *priv, QObject *obj) { 
+        if (!priv || !obj || QObjectPrivate::get(obj)->metaObject) return 0; 
+        return &priv->propertyCache[obj->metaObject()];
+    }
 
     struct Imports {
         Imports();
diff --git a/src/declarative/qml/qmlmetaproperty.cpp b/src/declarative/qml/qmlmetaproperty.cpp
index 350d84b..c445599 100644
--- a/src/declarative/qml/qmlmetaproperty.cpp
+++ b/src/declarative/qml/qmlmetaproperty.cpp
@@ -56,25 +56,53 @@ Q_DECLARE_METATYPE(QList<QObject *>);
 
 QT_BEGIN_NAMESPACE
 
-QmlMetaObjectCache::Data 
-QmlMetaObjectCache::property(const QString &name, const QMetaObject *metaObject)
+QmlMetaObjectCache::QmlMetaObjectCache()
+: propertyCache(0)
 {
-    QHash<QString, Data>::ConstIterator iter = properties.find(name);
-    if (iter != properties.end()) {
-        return *iter;
-    } else {
-        Data cacheData = { -1, -1 };
+}
+
+void QmlMetaObjectCache::init(const QMetaObject *metaObject)
+{
+    if (propertyCache || !metaObject)
+        return;
+
+    int propCount = metaObject->propertyCount();
+
+    propertyCache = new Data[propCount];
+    for (int ii = 0; ii < propCount; ++ii) {
+        QMetaProperty p = metaObject->property(ii);
+        propertyCache[ii].propType = p.userType();
+        propertyCache[ii].coreIndex = ii;
+        propertyCache[ii].name = QLatin1String(p.name());
+
+        propertyNameCache.insert(propertyCache[ii].name, ii);
+    }
+}
+
+QmlMetaObjectCache::~QmlMetaObjectCache()
+{
+    delete [] propertyCache;
+}
+
+QmlMetaObjectCache::Data *
+QmlMetaObjectCache::property(int index, const QMetaObject *metaObject)
+{
+    init(metaObject);
 
-        int idx = metaObject->indexOfProperty(name.toUtf8().constData());
-        if (idx == -1)
-            return cacheData;
+    return propertyCache + index;
+}
+
+QmlMetaObjectCache::Data *
+QmlMetaObjectCache::property(const QString &name, const QMetaObject *metaObject)
+{
+    init(metaObject);
 
-        QMetaProperty property = metaObject->property(idx);
-        cacheData.propType = property.userType();
-        cacheData.coreIndex = idx;
-        properties.insert(name, cacheData);
+    QHash<QString, int>::ConstIterator iter = propertyNameCache.find(name);
 
-        return cacheData;
+    if (iter != propertyNameCache.end()) {
+        return propertyCache + *iter;
+    } else {
+        return 0;
     }
 }
 
@@ -99,14 +127,6 @@ QmlMetaProperty::~QmlMetaProperty()
     delete d; d = 0;
 }
 
-struct CachedPropertyData {
-    CachedPropertyData(const QString &n, int pt, int ci)
-    : name(n), propType(pt), coreIdx(ci) {}
-    QString name;
-    int propType;
-    int coreIdx;
-};
-
 /*!
     Creates a QmlMetaProperty for the default property of \a obj. If there is no
     default property, an invalid QmlMetaProperty will be created.
@@ -218,15 +238,14 @@ void QmlMetaPropertyPrivate::initProperty(QObject *obj, const QString &name)
     } 
 
     // Property
-    if (!QObjectPrivate::get(obj)->metaObject && enginePrivate) {
-        // Can cache
-        QmlMetaObjectCache &cache = 
-            enginePrivate->propertyCache[obj->metaObject()];
-        QmlMetaObjectCache::Data data = cache.property(name, obj->metaObject());
-        if (data.coreIndex != -1) {
+    QmlMetaObjectCache *cache = QmlEnginePrivate::cache(enginePrivate, obj);
+    if (cache) {
+        QmlMetaObjectCache::Data *data = 
+            cache->property(name, obj->metaObject());
+        if (data) {
             type = QmlMetaProperty::Property;
-            propType = data.propType;
-            coreIdx = data.coreIndex;
+            propType = data->propType;
+            coreIdx = data->coreIndex;
         }
     } else {
         // Can't cache
@@ -1015,6 +1034,10 @@ quint32 QmlMetaPropertyPrivate::saveProperty(int core)
 */
 void QmlMetaProperty::restore(quint32 id, QObject *obj, QmlContext *ctxt)
 {
+    QmlEnginePrivate *enginePrivate = 0;
+    if (ctxt && ctxt->engine())
+        enginePrivate = QmlEnginePrivate::get(ctxt->engine());
+
     d->object = obj;
     d->context = ctxt;
 
@@ -1042,10 +1065,22 @@ void QmlMetaProperty::restore(quint32 id, QObject *obj, QmlContext *ctxt)
         d->valueTypeId = p.type();
 
     } else if (d->type & Property) {
-        QMetaProperty p(obj->metaObject()->property(id));
-        d->name = QLatin1String(p.name());
-        d->propType = p.userType();
+
+        QmlMetaObjectCache *cache = QmlEnginePrivate::cache(enginePrivate, obj);
+
         d->coreIdx = id;
+
+        if (cache) {
+            QmlMetaObjectCache::Data *data = 
+                cache->property(id, obj->metaObject());
+            d->propType = data->propType;
+            d->name = data->name;
+        } else {
+            QMetaProperty p(obj->metaObject()->property(id));
+            d->name = QLatin1String(p.name());
+            d->propType = p.userType();
+        }
+
     } else if (d->type & SignalProperty) {
         d->signal = obj->metaObject()->method(id);
         d->coreIdx = id;
diff --git a/src/declarative/qml/qmlmetaproperty_p.h b/src/declarative/qml/qmlmetaproperty_p.h
index 0410dd6..8e8966e 100644
--- a/src/declarative/qml/qmlmetaproperty_p.h
+++ b/src/declarative/qml/qmlmetaproperty_p.h
@@ -61,14 +61,23 @@ QT_BEGIN_NAMESPACE
 class QmlMetaObjectCache
 {
 public:
+    QmlMetaObjectCache();
+    ~QmlMetaObjectCache();
+
     struct Data {
         int propType;
         int coreIndex;
+        QString name;
     };
 
-    QHash<QString, Data> properties;
+    Data *property(const QString &, const QMetaObject *);
+    Data *property(int, const QMetaObject *);
+
+private:
+    void init(const QMetaObject *);
 
-    Data property(const QString &, const QMetaObject *);
+    Data *propertyCache;
+    QHash<QString, int> propertyNameCache;
 };
 
 class QmlContext;