QmlDesigner: remove lookups in the model

Use the result from try_emplace. So we save two additional lookups. The
code  gets simpler, too.

Change-Id: Id26024dd2f23f7e345b5b699b6a7b619669bfee1
Reviewed-by: Thomas Hartmann <thomas.hartmann@qt.io>

src/plugins/qmldesigner/libs/designercore/model/internalnode_p.h

@@ -11,8 +11,10 @@
 #include "internalsignalhandlerproperty.h"
 #include "internalvariantproperty.h"
 
+#include <abstractview.h>
 #include <auxiliarydata.h>
 #include <projectstorageids.h>
+#include <qmldesignerutils/memory.h>
 #include <tracing/qmldesignertracing.h>
 #include <utils/smallstring.h>
 
@@ -146,46 +148,47 @@ public:
     auto nodeProperty(PropertyNameView name) const { return property<InternalNodeProperty>(name); }
 
     template<typename Type>
-    Type *addProperty(PropertyNameView name)
+    std::tuple<Type *, AbstractView::PropertyChangeFlag> getProperty(PropertyNameView name)
     {
         auto [iter, inserted] = m_nameProperties.try_emplace(
-            name, std::make_shared<Type>(name, shared_from_this()));
+            name, makeLazySharedPtr<Type, InternalProperty>(name, shared_from_this()));
 
+        auto flags = AbstractView::NoAdditionalChanges;
         if (inserted)
-            return static_cast<Type *>(iter->second.get());
+            flags = AbstractView::PropertiesAdded;
 
-        return nullptr;
+        return std::make_tuple(static_cast<Type *>(iter->second.get()), flags);
     }
 
-    auto addBindingProperty(PropertyNameView name)
+    auto getBindingProperty(PropertyNameView name)
     {
-        return addProperty<InternalBindingProperty>(name);
+        return getProperty<InternalBindingProperty>(name);
     }
 
-    auto addSignalHandlerProperty(PropertyNameView name)
+    auto getSignalHandlerProperty(PropertyNameView name)
     {
-        return addProperty<InternalSignalHandlerProperty>(name);
+        return getProperty<InternalSignalHandlerProperty>(name);
     }
 
-    auto addSignalDeclarationProperty(PropertyNameView name)
+    auto getSignalDeclarationProperty(PropertyNameView name)
     {
-        return addProperty<InternalSignalDeclarationProperty>(name);
+        return getProperty<InternalSignalDeclarationProperty>(name);
     }
 
-    auto addNodeListProperty(PropertyNameView name)
+    auto getNodeListProperty(PropertyNameView name)
     {
-        return addProperty<InternalNodeListProperty>(name);
+        return getProperty<InternalNodeListProperty>(name);
     }
 
-    auto addVariantProperty(PropertyNameView name)
+    auto getVariantProperty(PropertyNameView name)
     {
-        return addProperty<InternalVariantProperty>(name);
+        return getProperty<InternalVariantProperty>(name);
     }
 
-    auto addNodeProperty(PropertyNameView name, const TypeName &dynamicTypeName)
+    auto getNodeProperty(PropertyNameView name, const TypeName &dynamicTypeName)
     {
-        auto property = addProperty<InternalNodeProperty>(name);
+        auto property = getProperty<InternalNodeProperty>(name);
-        property->setDynamicTypeName(dynamicTypeName);
+        std::get<0>(property)->setDynamicTypeName(dynamicTypeName);
 
         return property;
     }

src/plugins/qmldesigner/libs/designercore/model/model.cpp

@@ -341,7 +341,7 @@ InternalNodePointer ModelPrivate::createNode(TypeNameView typeName,
     using PropertyPair = QPair<PropertyName, QVariant>;
 
     for (const PropertyPair &propertyPair : propertyList) {
-        newNode->addVariantProperty(propertyPair.first);
+        newNode->getVariantProperty(propertyPair.first);
         newNode->variantProperty(propertyPair.first)->setValue(propertyPair.second);
     }
 
@@ -1379,14 +1379,7 @@ void ModelPrivate::setBindingProperty(const InternalNodePointer &node,
                                       PropertyNameView name,
                                       const QString &expression)
 {
-    AbstractView::PropertyChangeFlags propertyChange = AbstractView::NoAdditionalChanges;
+    auto [bindingProperty, propertyChange] = node->getBindingProperty(name);
-    InternalBindingProperty *bindingProperty = nullptr;
-    if (auto property = node->property(name)) {
-        bindingProperty = property->to<PropertyType::Binding>();
-    } else {
-        bindingProperty = node->addBindingProperty(name);
-        propertyChange = AbstractView::PropertiesAdded;
-    }
 
     notifyBindingPropertiesAboutToBeChanged({bindingProperty});
     bindingProperty->setExpression(expression);
@@ -1415,14 +1408,7 @@ void ModelPrivate::setSignalHandlerProperty(const InternalNodePointer &node,
                                             PropertyNameView name,
                                             const QString &source)
 {
-    AbstractView::PropertyChangeFlags propertyChange = AbstractView::NoAdditionalChanges;
+    auto [signalHandlerProperty, propertyChange] = node->getSignalHandlerProperty(name);
-    InternalSignalHandlerProperty *signalHandlerProperty = nullptr;
-    if (auto property = node->property(name)) {
-        signalHandlerProperty = property->to<PropertyType::SignalHandler>();
-    } else {
-        signalHandlerProperty = node->addSignalHandlerProperty(name);
-        propertyChange = AbstractView::PropertiesAdded;
-    }
 
     signalHandlerProperty->setSource(source);
     notifySignalHandlerPropertiesChanged({signalHandlerProperty}, propertyChange);
@@ -1432,14 +1418,7 @@ void ModelPrivate::setSignalDeclarationProperty(const InternalNodePointer &node,
                                                 PropertyNameView name,
                                                 const QString &signature)
 {
-    AbstractView::PropertyChangeFlags propertyChange = AbstractView::NoAdditionalChanges;
+    auto [signalDeclarationProperty, propertyChange] = node->getSignalDeclarationProperty(name);
-    InternalSignalDeclarationProperty *signalDeclarationProperty = nullptr;
-    if (auto property = node->property(name)) {
-        signalDeclarationProperty = property->to<PropertyType::SignalDeclaration>();
-    } else {
-        signalDeclarationProperty = node->addSignalDeclarationProperty(name);
-        propertyChange = AbstractView::PropertiesAdded;
-    }
 
     signalDeclarationProperty->setSignature(signature);
     notifySignalDeclarationPropertiesChanged({signalDeclarationProperty}, propertyChange);
@@ -1449,14 +1428,7 @@ void ModelPrivate::setVariantProperty(const InternalNodePointer &node,
                                       PropertyNameView name,
                                       const QVariant &value)
 {
-    AbstractView::PropertyChangeFlags propertyChange = AbstractView::NoAdditionalChanges;
+    auto [variantProperty, propertyChange] = node->getVariantProperty(name);
-    InternalVariantProperty *variantProperty = nullptr;
-    if (auto property = node->property(name)) {
-        variantProperty = property->to<PropertyType::Variant>();
-    } else {
-        variantProperty = node->addVariantProperty(name);
-        propertyChange = AbstractView::PropertiesAdded;
-    }
 
     variantProperty->setValue(value);
     variantProperty->resetDynamicTypeName();
@@ -1468,14 +1440,7 @@ void ModelPrivate::setDynamicVariantProperty(const InternalNodePointer &node,
                                              const TypeName &dynamicPropertyType,
                                              const QVariant &value)
 {
-    AbstractView::PropertyChangeFlags propertyChange = AbstractView::NoAdditionalChanges;
+    auto [variantProperty, propertyChange] = node->getVariantProperty(name);
-    InternalVariantProperty *variantProperty = nullptr;
-    if (auto property = node->property(name)) {
-        variantProperty = property->to<PropertyType::Variant>();
-    } else {
-        variantProperty = node->addVariantProperty(name);
-        propertyChange = AbstractView::PropertiesAdded;
-    }
 
     variantProperty->setDynamicValue(dynamicPropertyType, value);
     notifyVariantPropertiesChanged(node, PropertyNameViews({name}), propertyChange);
@@ -1486,14 +1451,7 @@ void ModelPrivate::setDynamicBindingProperty(const InternalNodePointer &node,
                                              const TypeName &dynamicPropertyType,
                                              const QString &expression)
 {
-    AbstractView::PropertyChangeFlags propertyChange = AbstractView::NoAdditionalChanges;
+    auto [bindingProperty, propertyChange] = node->getBindingProperty(name);
-    InternalBindingProperty *bindingProperty = nullptr;
-    if (auto property = node->property(name)) {
-        bindingProperty = property->to<PropertyType::Binding>();
-    } else {
-        bindingProperty = node->addBindingProperty(name);
-        propertyChange = AbstractView::PropertiesAdded;
-    }
 
     notifyBindingPropertiesAboutToBeChanged({bindingProperty});
     bindingProperty->setDynamicExpression(dynamicPropertyType, expression);
@@ -1524,16 +1482,14 @@ void ModelPrivate::reparentNode(const InternalNodePointer &parentNode,
                                 propertyChange);
 
     InternalNodeAbstractProperty *newParentProperty = nullptr;
-    if (auto property = parentNode->property(name)) {
+    AbstractView::PropertyChangeFlags newPropertyChange = AbstractView::NoAdditionalChanges;
-        newParentProperty = property->to<PropertyType::Node, PropertyType::NodeList>();
-    } else {
-        if (list)
-            newParentProperty = parentNode->addNodeListProperty(name);
-        else
-            newParentProperty = parentNode->addNodeProperty(name, dynamicTypeName);
 
-        propertyChange |= AbstractView::PropertiesAdded;
+    if (list)
-    }
+        std::tie(newParentProperty, newPropertyChange) = parentNode->getNodeListProperty(name);
+    else
+        std::tie(newParentProperty, newPropertyChange) = parentNode->getNodeProperty(name,
+                                                                                     dynamicTypeName);
+    propertyChange |= newPropertyChange;
 
     Q_ASSERT(newParentProperty);
 

src/plugins/qmldesigner/libs/qmldesignerutils/memory.h

@@ -8,21 +8,20 @@
 
 namespace QmlDesigner {
 
-template<typename Pointer, typename... Arguments>
+template<typename Type, typename ResultType, typename... Arguments>
-class LazyPtr
+class LazySharedPtr
 {
-    using ResultType = Pointer::element_type;
 
 public:
-    LazyPtr(Arguments &&...arguments)
+    LazySharedPtr(Arguments &&...arguments)
         : m_arguments{std::forward_as_tuple(std::forward<Arguments>(arguments)...)}
     {}
 
-    operator Pointer() const
+    operator std::shared_ptr<ResultType>() const
     {
         return std::apply(
             [](auto &&...arguments) {
-                return Pointer(new ResultType(std::forward<decltype(arguments)>(arguments)...));
+                return std::make_shared<Type>(std::forward<decltype(arguments)>(arguments)...);
             },
             m_arguments);
     }
@@ -31,22 +30,10 @@ private:
     std::tuple<Arguments...> m_arguments;
 };
 
-template<typename ResultType, typename... Arguments>
+template<typename Type, typename ResultType, typename... Arguments>
-using LazyUniquePtr = LazyPtr<std::unique_ptr<ResultType>, Arguments...>;
+LazySharedPtr<Type, ResultType, Arguments...> makeLazySharedPtr(Arguments &&...arguments)
-
-template<typename Result, typename... Arguments>
-LazyUniquePtr<Result, Arguments...> makeLazyUniquePtr(Arguments &&...arguments)
 {
-    return LazyUniquePtr<Result, Arguments...>(std::forward<Arguments>(arguments)...);
+    return LazySharedPtr<Type, ResultType, Arguments...>(std::forward<Arguments>(arguments)...);
-}
-
-template<typename ResultType, typename... Arguments>
-using LazySharedPtr = LazyPtr<std::shared_ptr<ResultType>, Arguments...>;
-
-template<typename ResultType, typename... Arguments>
-LazySharedPtr<ResultType, Arguments...> makeLazySharedPtr(Arguments &&...arguments)
-{
-    return LazySharedPtr<ResultType, Arguments...>(std::forward<Arguments>(arguments)...);
 }
 
 } // namespace QmlDesigner