QML: Clean up and re-order QQmlPropertyPrivate::write

The most common cases of property writes now come first.

Change-Id: I225b73746120870d9ca01d09983ad225e32bd99c
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

1 files changed, 81 insertions, 65 deletions

diff --git a/src/qml/qml/qqmlproperty.cpp b/src/qml/qml/qqmlproperty.cpp
index 64852f1cfe..b3eb0a5619 100644
--- a/src/qml/qml/qqmlproperty.cpp
+++ b/src/qml/qml/qqmlproperty.cpp
@@ -1189,133 +1189,149 @@ bool QQmlPropertyPrivate::write(QObject *object,
                                         const QVariant &value, QQmlContextData *context,
                                         QQmlPropertyData::WriteFlags flags)
 {
-    int coreIdx = property.coreIndex;
+    const int propertyType = property.propType;
+    const int variantType = value.userType();
 
     if (property.isEnum()) {
         QMetaProperty prop = object->metaObject()->property(property.coreIndex);
         QVariant v = value;
         // Enum values come through the script engine as doubles
-        if (value.userType() == QVariant::Double) {
+        if (variantType == QVariant::Double) {
             double integral;
             double fractional = std::modf(value.toDouble(), &integral);
             if (qFuzzyIsNull(fractional))
                 v.convert(QVariant::Int);
         }
-        return writeEnumProperty(prop, coreIdx, object, v, flags);
+        return writeEnumProperty(prop, property.coreIndex, object, v, flags);
     }
 
-    int propertyType = property.propType;
-    int variantType = value.userType();
-
     QQmlEnginePrivate *enginePriv = QQmlEnginePrivate::get(context);
+    const bool isUrl = propertyType == QVariant::Url; // handled separately
+
+    // The cases below are in approximate order of likelyhood:
+    if (propertyType == variantType && !isUrl && propertyType != qMetaTypeId<QList<QUrl>>() && !property.isQList()) {
+        return property.writeProperty(object, const_cast<void *>(value.constData()), flags);
+    } else if (property.isQObject()) {
+        QQmlMetaObject valMo = rawMetaObjectForType(enginePriv, variantType);
+        if (valMo.isNull())
+            return false;
+        QObject *o = *static_cast<QObject *const *>(value.constData());
+        QQmlMetaObject propMo = rawMetaObjectForType(enginePriv, propertyType);
 
-    if (propertyType == QVariant::Url) {
+        if (o)
+            valMo = o;
 
+        if (QQmlMetaObject::canConvert(valMo, propMo)) {
+            return property.writeProperty(object, &o, flags);
+        } else if (!o && QQmlMetaObject::canConvert(propMo, valMo)) {
+            // In the case of a null QObject, we assign the null if there is
+            // any change that the null variant type could be up or down cast to
+            // the property type.
+            return property.writeProperty(object, &o, flags);
+        } else {
+            return false;
+        }
+    } else if (value.canConvert(propertyType) && !isUrl && variantType != QVariant::String && propertyType != qMetaTypeId<QList<QUrl>>() && !property.isQList()) {
+        // common cases:
+        switch (propertyType) {
+        case QMetaType::Bool: {
+            bool b = value.toBool();
+            return property.writeProperty(object, &b, flags);
+        }
+        case QMetaType::Int: {
+            int i = value.toInt();
+            return property.writeProperty(object, &i, flags);
+        }
+        case QMetaType::Double: {
+            double d = value.toDouble();
+            return property.writeProperty(object, &d, flags);
+        }
+        case QMetaType::Float: {
+            float f = value.toFloat();
+            return property.writeProperty(object, &f, flags);
+        }
+        case QMetaType::QString: {
+            QString s = value.toString();
+            return property.writeProperty(object, &s, flags);
+        }
+        default: { // "fallback":
+            QVariant v = value;
+            v.convert(propertyType);
+            return property.writeProperty(object, const_cast<void *>(v.constData()), flags);
+        }
+        }
+    } else if (propertyType == qMetaTypeId<QVariant>()) {
+        return property.writeProperty(object, const_cast<QVariant *>(&value), flags);
+    } else if (isUrl) {
         QUrl u;
-        bool found = false;
         if (variantType == QVariant::Url) {
             u = value.toUrl();
-            found = true;
         } else if (variantType == QVariant::ByteArray) {
             QString input(QString::fromUtf8(value.toByteArray()));
             // Encoded dir-separators defeat QUrl processing - decode them first
             input.replace(QLatin1String("%2f"), QLatin1String("/"), Qt::CaseInsensitive);
             u = QUrl(input);
-            found = true;
         } else if (variantType == QVariant::String) {
             QString input(value.toString());
             // Encoded dir-separators defeat QUrl processing - decode them first
             input.replace(QLatin1String("%2f"), QLatin1String("/"), Qt::CaseInsensitive);
             u = QUrl(input);
-            found = true;
-        }
-
-        if (!found)
+        } else {
             return false;
+        }
 
         if (context && u.isRelative() && !u.isEmpty())
             u = context->resolvedUrl(u);
         return property.writeProperty(object, &u, flags);
-
-    } else if (propertyType == qMetaTypeId<QList<QUrl> >()) {
-        QList<QUrl> urlSeq = resolvedUrlSequence(value, context).value<QList<QUrl> >();
+    } else if (propertyType == qMetaTypeId<QList<QUrl>>()) {
+        QList<QUrl> urlSeq = resolvedUrlSequence(value, context).value<QList<QUrl>>();
         return property.writeProperty(object, &urlSeq, flags);
-    } else if (variantType == propertyType) {
-
-        return property.writeProperty(object, const_cast<void *>(value.constData()), flags);
-
-    } else if (qMetaTypeId<QVariant>() == propertyType) {
-
-        return property.writeProperty(object, const_cast<QVariant *>(&value), flags);
-
-    } else if (property.isQObject()) {
-
-        QQmlMetaObject valMo = rawMetaObjectForType(enginePriv, value.userType());
-
-        if (valMo.isNull())
-            return false;
-
-        QObject *o = *(QObject *const *)value.constData();
-        QQmlMetaObject propMo = rawMetaObjectForType(enginePriv, propertyType);
-
-        if (o) valMo = o;
-
-        if (QQmlMetaObject::canConvert(valMo, propMo)) {
-            return property.writeProperty(object, &o, flags);
-        } else if (!o && QQmlMetaObject::canConvert(propMo, valMo)) {
-            // In the case of a null QObject, we assign the null if there is
-            // any change that the null variant type could be up or down cast to
-            // the property type.
-            return property.writeProperty(object, &o, flags);
-        } else {
-            return false;
-        }
-
     } else if (property.isQList()) {
-
         QQmlMetaObject listType;
 
         if (enginePriv) {
             listType = enginePriv->rawMetaObjectForType(enginePriv->listType(property.propType));
         } else {
             QQmlType *type = QQmlMetaType::qmlType(QQmlMetaType::listType(property.propType));
-            if (!type) return false;
+            if (!type)
+                return false;
             listType = type->baseMetaObject();
         }
-        if (listType.isNull()) return false;
+        if (listType.isNull())
+            return false;
 
         QQmlListProperty<void> prop;
         property.readProperty(object, &prop);
 
-        if (!prop.clear) return false;
+        if (!prop.clear)
+            return false;
 
         prop.clear(&prop);
 
-        if (value.userType() == qMetaTypeId<QQmlListReference>()) {
+        if (variantType == qMetaTypeId<QQmlListReference>()) {
             QQmlListReference qdlr = value.value<QQmlListReference>();
 
             for (int ii = 0; ii < qdlr.count(); ++ii) {
                 QObject *o = qdlr.at(ii);
                 if (o && !QQmlMetaObject::canConvert(o, listType))
-                    o = 0;
-                prop.append(&prop, (void *)o);
+                    o = nullptr;
+                prop.append(&prop, o);
             }
-        } else if (value.userType() == qMetaTypeId<QList<QObject *> >()) {
+        } else if (variantType == qMetaTypeId<QList<QObject *> >()) {
             const QList<QObject *> &list = qvariant_cast<QList<QObject *> >(value);
 
             for (int ii = 0; ii < list.count(); ++ii) {
                 QObject *o = list.at(ii);
                 if (o && !QQmlMetaObject::canConvert(o, listType))
-                    o = 0;
-                prop.append(&prop, (void *)o);
+                    o = nullptr;
+                prop.append(&prop, o);
             }
         } else {
             QObject *o = enginePriv?enginePriv->toQObject(value):QQmlMetaType::toQObject(value);
             if (o && !QQmlMetaObject::canConvert(o, listType))
-                o = 0;
-            prop.append(&prop, (void *)o);
+                o = nullptr;
+            prop.append(&prop, o);
         }
-
     } else {
         Q_ASSERT(variantType != propertyType);
 
@@ -1355,7 +1371,8 @@ bool QQmlPropertyPrivate::write(QObject *object,
                 // successful conversion.
                 Q_ASSERT(v.userType() == propertyType);
                 ok = true;
-            } else if ((uint)propertyType >= QVariant::UserType && variantType == QVariant::String) {
+            } else if (static_cast<uint>(propertyType) >= QVariant::UserType &&
+                       variantType == QVariant::String) {
                 QQmlMetaType::StringConverter con = QQmlMetaType::customStringConverter(propertyType);
                 if (con) {
                     v = con(value.toString());
@@ -1414,10 +1431,9 @@ QQmlMetaObject QQmlPropertyPrivate::rawMetaObjectForType(QQmlEnginePrivate *engi
         return metaType.metaObject();
     if (engine)
         return engine->rawMetaObjectForType(userType);
-    QQmlType *type = QQmlMetaType::qmlType(userType);
-    if (type)
+    if (QQmlType *type = QQmlMetaType::qmlType(userType))
         return QQmlMetaObject(type->baseMetaObject());
-    return QQmlMetaObject((QObject*)0);
+    return QQmlMetaObject();
 }
 
 /*!