RunConfigurationFactory: Simplify RunConfigFactory::create use

A for (f : X.allFs()) if (f.canHandle(t)) { f.doIt() ... } }
pattern can be replaced by some  static X.doIt(t), and
item.factory->create(target, item) by some item.create(target).

Change-Id: I65df8b71e03272d60f41a16795ea43a0fdb262ef
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>

src/plugins/projectexplorer/runconfiguration.cpp

@@ -539,30 +539,28 @@ bool RunConfigurationFactory::canCreateHelper(Target *, const QString &) const
     return true;
 }
 
-RunConfiguration *RunConfigurationFactory::create(Target *parent,
+RunConfiguration *RunConfigurationCreationInfo::create(Target *target) const
-                                                   const RunConfigurationCreationInfo &info) const
 {
-    if (!canHandle(parent))
+    QTC_ASSERT(factory->canHandle(target), return nullptr);
-        return nullptr;
+    QTC_ASSERT(id == factory->runConfigurationBaseId(), return nullptr);
-    if (info.id != m_runConfigBaseId)
+
-        return nullptr;
+    if (!factory->canCreateHelper(target, extra))
-    if (!canCreateHelper(parent, info.extra))
         return nullptr;
 
-    QTC_ASSERT(m_creator, return nullptr);
+    QTC_ASSERT(factory->m_creator, return nullptr);
-    RunConfiguration *rc = m_creator(parent);
+    RunConfiguration *rc = factory->m_creator(target);
     if (!rc)
         return nullptr;
 
     // "FIX" ids by mangling in the extra data (build system target etc)
     // for compatibility for the current format used in settings.
-    if (!info.extra.isEmpty()) {
+    if (!extra.isEmpty()) {
         QVariantMap data = rc->toMap();
-        data[ProjectConfiguration::settingsIdKey()] = info.id.withSuffix(info.extra).toString();
+        data[ProjectConfiguration::settingsIdKey()] = id.withSuffix(extra).toString();
         rc->fromMap(data);
     }
 
-    rc->doAdditionalSetup(info);
+    rc->doAdditionalSetup(*this);
 
     return rc;
 }
@@ -595,6 +593,16 @@ const QList<RunConfigurationFactory *> RunConfigurationFactory::allFactories()
     return g_runConfigurationFactories;
 }
 
+const QList<RunConfigurationCreationInfo> RunConfigurationFactory::creatorsForTarget(Target *parent)
+{
+    QList<RunConfigurationCreationInfo> items;
+    for (RunConfigurationFactory *factory : g_runConfigurationFactories) {
+        if (factory->canHandle(parent))
+            items.append(factory->availableCreators(parent));
+    }
+    return items;
+}
+
 FixedRunConfigurationFactory::FixedRunConfigurationFactory(const QString &displayName,
                                                            bool addDeviceName) :
     m_fixedBuildTarget(displayName),

src/plugins/projectexplorer/runconfiguration.h

@@ -274,7 +274,7 @@ protected:
 private:
     static void addAspectFactory(const AspectFactory &aspectFactory);
 
-    friend class RunConfigurationFactory;
+    friend class RunConfigurationCreationInfo;
 
     QList<IRunConfigurationAspect *> m_aspects;
 };
@@ -296,6 +296,8 @@ public:
           useTerminal(useTerminal)
     {}
 
+    RunConfiguration *create(Target *target) const;
+
     const RunConfigurationFactory *factory = nullptr;
     Core::Id id;
     QString extra;
@@ -314,21 +316,19 @@ public:
 
     static const QList<RunConfigurationFactory *> allRunConfigurationFactories();
 
-    virtual QList<RunConfigurationCreationInfo> availableCreators(Target *parent) const;
-
     virtual bool canHandle(Target *target) const;
 
-    RunConfiguration *create(Target *parent, const RunConfigurationCreationInfo &info) const;
-
     static RunConfiguration *restore(Target *parent, const QVariantMap &map);
     static RunConfiguration *clone(Target *parent, RunConfiguration *source);
     static const QList<RunConfigurationFactory *> allFactories();
+    static const QList<RunConfigurationCreationInfo> creatorsForTarget(Target *parent);
 
     Core::Id runConfigurationBaseId() const { return m_runConfigBaseId; }
 
     static QString decoratedTargetName(const QString targetName, Target *kit);
 
 protected:
+    virtual QList<RunConfigurationCreationInfo> availableCreators(Target *parent) const;
     virtual bool canCreateHelper(Target *parent, const QString &buildTarget) const;
 
     using RunConfigurationCreator = std::function<RunConfiguration *(Target *)>;
@@ -349,6 +349,7 @@ protected:
     RunConfigurationCreationInfo convert(const QString &displayName, const QString &targetName = QString()) const;
 
 private:
+    friend class RunConfigurationCreationInfo;
     RunConfigurationCreator m_creator;
     Core::Id m_runConfigBaseId;
     QList<Core::Id> m_supportedProjectTypes;

src/plugins/projectexplorer/runsettingspropertiespage.cpp

@@ -238,23 +238,19 @@ void RunSettingsWidget::aboutToShowAddMenu()
                 this, &RunSettingsWidget::cloneRunConfiguration);
     }
     QList<QAction *> menuActions;
-    for (RunConfigurationFactory *factory : RunConfigurationFactory::allRunConfigurationFactories()) {
+    for (const RunConfigurationCreationInfo &item :
-        if (!factory->canHandle(m_target))
+            RunConfigurationFactory::creatorsForTarget(m_target)) {
-            continue;
+        auto action = new QAction(item.displayName, m_addRunMenu);
-        const QList<RunConfigurationCreationInfo> items = factory->availableCreators(m_target);
+        connect(action, &QAction::triggered, [item, this] {
-        for (const RunConfigurationCreationInfo &item : items) {
+            RunConfiguration *newRC = item.create(m_target);
-            auto action = new QAction(item.displayName, m_addRunMenu);
+            if (!newRC)
-            connect(action, &QAction::triggered, [item, this] {
+                return;
-                RunConfiguration *newRC = item.factory->create(m_target, item);
+            QTC_CHECK(newRC->id() == item.id);
-                if (!newRC)
+            m_target->addRunConfiguration(newRC);
-                    return;
+            m_target->setActiveRunConfiguration(newRC);
-                QTC_CHECK(newRC->id() == item.id);
+            m_removeRunToolButton->setEnabled(m_target->runConfigurations().size() > 1);
-                m_target->addRunConfiguration(newRC);
+        });
-                m_target->setActiveRunConfiguration(newRC);
+        menuActions.append(action);
-                m_removeRunToolButton->setEnabled(m_target->runConfigurations().size() > 1);
-            });
-            menuActions.append(action);
-        }
     }
 
     Utils::sort(menuActions, &QAction::text);

src/plugins/projectexplorer/target.cpp

@@ -536,22 +536,11 @@ void Target::updateDefaultDeployConfigurations()
 
 void Target::updateDefaultRunConfigurations()
 {
-    // find all RC ids that can get created:
+    // Manual and Auto
-    QList<RunConfigurationCreationInfo> allAvailableFactories;
+    const QList<RunConfigurationCreationInfo> creators
-    QList<RunConfigurationCreationInfo> autoCreateFactories;
+            = RunConfigurationFactory::creatorsForTarget(this);
 
-    for (RunConfigurationFactory *rcFactory : RunConfigurationFactory::allFactories()) {
+    if (creators.isEmpty()) {
-        if (rcFactory->canHandle(this)) {
-            const QList<RunConfigurationCreationInfo> creators = rcFactory->availableCreators(this);
-            for (const RunConfigurationCreationInfo &creator : creators) {
-                allAvailableFactories.append(creator); // Manual and Auto
-                if (creator.creationMode == RunConfigurationCreationInfo::AlwaysCreate)
-                    autoCreateFactories.append(creator);  // Auto only.
-            }
-        }
-    }
-
-    if (allAvailableFactories.isEmpty()) {
         qWarning("No run configuration factory found for target id '%s'.", qPrintable(id().toString()));
         return;
     }
@@ -573,7 +562,7 @@ void Target::updateDefaultRunConfigurations()
     QList<RunConfigurationCreationInfo> existing;
     foreach (RunConfiguration *rc, existingConfigured) {
         bool present = false;
-        for (const RunConfigurationCreationInfo &item : allAvailableFactories) {
+        for (const RunConfigurationCreationInfo &item : creators) {
             if (item.id == rc->id() && item.extra == rc->extraId()) {
                 existing.append(item);
                 present = true;
@@ -584,8 +573,10 @@ void Target::updateDefaultRunConfigurations()
     }
     configuredCount -= toRemove.count();
 
-    // Create new RCs and put them into newConfigured/newUnconfigured
+    // Create new "automatic" RCs and put them into newConfigured/newUnconfigured
-    foreach (const RunConfigurationCreationInfo &item, autoCreateFactories) {
+    foreach (const RunConfigurationCreationInfo &item, creators) {
+        if (item.creationMode == RunConfigurationCreationInfo::ManualCreationOnly)
+            continue;
         bool exists = false;
         for (const RunConfigurationCreationInfo &ex : existing) {
             if (ex.id == item.id && ex.extra == item.extra)
@@ -594,7 +585,7 @@ void Target::updateDefaultRunConfigurations()
         if (exists)
             continue;
 
-        RunConfiguration *rc = item.factory->create(this, item);
+        RunConfiguration *rc = item.create(this);
         if (!rc)
             continue;
         QTC_CHECK(rc->id() == item.id);