Rewrite the component getter mess, remove superfluous methods.

Now we can combine some enum values to achieve the same as before
with the several getter functions, removes the clutter from the API.

Change-Id: I6368b0ff77821ac95d1defaec4af27dd7d383396
Reviewed-by: Jarek Kobus <jaroslaw.kobus@digia.com>

7 files changed, 106 insertions, 134 deletions

diff --git a/src/libs/installer/component_p.cpp b/src/libs/installer/component_p.cpp
index 7c7ec30d6..58477b2dd 100644
--- a/src/libs/installer/component_p.cpp
+++ b/src/libs/installer/component_p.cpp
@@ -90,7 +90,7 @@ ScriptEngine *ComponentPrivate::scriptEngine() const
 ComponentModelHelper::ComponentModelHelper()
 {
     setCheckState(Qt::Unchecked);
-    setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsUserCheckable);
+    setFlags(Qt::ItemFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsUserCheckable));
 }
 
 /*!
diff --git a/src/libs/installer/componentmodel.cpp b/src/libs/installer/componentmodel.cpp
index 17da07a04..98b6f884d 100644
--- a/src/libs/installer/componentmodel.cpp
+++ b/src/libs/installer/componentmodel.cpp
@@ -416,11 +416,7 @@ void ComponentModel::slotModelReset()
 void ComponentModel::onVirtualStateChanged()
 {
     // If the virtual state of a component changes, force a reset of the component model.
-    // Make sure to pass the right components list depending on the package manager run mode.
-    if (m_core->isUpdater())
-        setRootComponents(m_core->updaterComponents());
-    else
-        setRootComponents(m_core->rootComponents());
+    setRootComponents(m_core->components(PackageManagerCore::ComponentType::Root));
 }
 
 
diff --git a/src/libs/installer/packagemanagercore.cpp b/src/libs/installer/packagemanagercore.cpp
index e83b0471c..67aabce94 100644
--- a/src/libs/installer/packagemanagercore.cpp
+++ b/src/libs/installer/packagemanagercore.cpp
@@ -518,7 +518,7 @@ quint64 PackageManagerCore::requiredDiskSpace() const
 {
     quint64 result = 0;
 
-    foreach (QInstaller::Component *component, rootComponents())
+    foreach (QInstaller::Component *component, components(ComponentType::Root))
         result += component->updateUncompressedSize();
 
     return result;
@@ -1116,33 +1116,6 @@ ScriptEngine *PackageManagerCore::controlScriptEngine() const
 }
 
 /*!
-    Returns the number of components in the list for installer and package manager mode. Might return 0 in
-    case the engine has only been run in updater mode or no components have been fetched.
-*/
-int PackageManagerCore::rootComponentCount() const
-{
-    return d->m_rootComponents.size();
-}
-
-/*!
-    Returns the component at index position \a i in the components list. \a i must be a valid index
-    position in the list (i.e., 0 <= i < rootComponentCount()).
-*/
-Component *PackageManagerCore::rootComponent(int i) const
-{
-    return d->m_rootComponents.value(i, 0);
-}
-
-/*!
-    Returns a list of root components if run in installer or package manager mode. Might return an empty list
-    in case the engine has only been run in updater mode or no components have been fetched.
-*/
-QList<Component*> PackageManagerCore::rootComponents() const
-{
-    return d->m_rootComponents;
-}
-
-/*!
     Appends a component as root component to the internal storage for installer or package manager components.
     To append a component as a child to an already existing component, use Component::appendComponent(). Emits
     the componentAdded() signal.
@@ -1154,44 +1127,59 @@ void PackageManagerCore::appendRootComponent(Component *component)
 }
 
 /*!
-    Returns a list of root components and all of their descendant components if run in installer or package manager mode.
-    Might return an empty list in case the engine has only been run in updater mode or no components have been fetched.
-*/
-QList<Component*> PackageManagerCore::rootAndChildComponents() const
-{
-    QList<Component*> result = d->m_rootComponents;
-    foreach (QInstaller::Component *component, d->m_rootComponents)
-        result += component->childComponents(Component::Descendants);
-    return result;
-}
+    \enum ComponentType
 
-/*!
-    \qmlmethod int QInstaller::updaterComponentCount()
+    This enum is used with components() to describe what type of \C Component list this function
+    should return.
 
-    Returns the number of components in the list for updater mode. Might return 0 in case the engine has only
-    been run in installer or package manager mode or no components have been fetched.
-*/
-int PackageManagerCore::updaterComponentCount() const
-{
-    return d->m_updaterComponents.size();
-}
+    \value Root
+        Return a list of root components.
 
-/*!
-    Returns the component at index position \a i in the updates component list. \a i must be a valid index
-    position in the list (i.e., 0 <= i < updaterComponentCount()).
+    \value Descendants
+        Return a list of all descendant components. \note In updater mode the list is empty,
+        because component updates cannot have children.
+
+    \value Dependencies
+        Return a list of all available dependencies when run as updater. \note In Installer,
+        package manager and uninstaller mode, this will always result in an empty list.
+
+    \value Replacements
+        Return a list of all available replacement components relevant to the run mode.
+
+    \value AllNoReplacements
+        Return a list of available components, including root, descendant and dependency
+        components relevant to the run mode.
+
+    \value All
+        Return a list of all available components, including root, descendant, dependency and
+        replacement components relevant to the run mode.
 */
-Component *PackageManagerCore::updaterComponent(int i) const
-{
-    return d->m_updaterComponents.value(i, 0);
-}
 
 /*!
-    Returns a list of components if run in updater mode. Might return an empty list in case the engine has only
-    been run in installer or package manager mode or no components have been fetched.
+    Returns a list of components depending on the component types passed in \a mask.
 */
-QList<Component*> PackageManagerCore::updaterComponents() const
+QList<Component *> PackageManagerCore::components(ComponentTypes mask) const
 {
-    return d->m_updaterComponents;
+    QList<Component *> components;
+
+    const bool updater = isUpdater();
+    if (mask.testFlag(ComponentType::Root))
+        components += updater ? d->m_updaterComponents : d->m_rootComponents;
+    if (mask.testFlag(ComponentType::Replacements))
+        components += updater ? d->m_updaterDependencyReplacements : d->m_rootDependencyReplacements;
+
+    if (!updater) {
+        if (mask.testFlag(ComponentType::Descendants)) {
+            foreach (QInstaller::Component *component, d->m_rootComponents)
+                components += component->childComponents(Component::Descendants);
+        }
+    } else {
+        if (mask.testFlag(ComponentType::Dependencies))
+            components.append(d->m_updaterComponentsDeps);
+        // No descendants here, updates are always a flat list and cannot have children!
+    }
+
+    return components;
 }
 
 /*!
@@ -1205,19 +1193,6 @@ void PackageManagerCore::appendUpdaterComponent(Component *component)
 }
 
 /*!
-    Returns a list of all available components found during a fetch. Depending on the run mode the
-    returned list might have different values. \note: This function will return all components and
-    possible replacement components as well.
-*/
-QList<Component*> PackageManagerCore::availableComponents() const
-{
-    if (isUpdater())
-        return d->m_updaterComponents + d->m_updaterComponentsDeps + d->m_updaterDependencyReplacements;
-
-    return rootAndChildComponents() + d->m_rootDependencyReplacements;
-}
-
-/*!
     \qmlmethod Component QInstaller::componentByName(string name)
 
     Returns a component matching \a name. \a name can also contains a version requirement.
@@ -1238,11 +1213,8 @@ Component *PackageManagerCore::componentByName(const QString &name) const
         fixedName = name.section(QLatin1Char('-'), 0, 0);
     }
 
-    const QList<Component *> components = isUpdater()
-            ? updaterComponents() + d->m_updaterComponentsDeps
-            : rootAndChildComponents();
-
-    foreach (Component *component, components) {
+    const QList<Component *> list = components(ComponentType::AllNoReplacements);
+    foreach (Component *component, list) {
         if (componentMatches(component, fixedName, fixedVersion))
             return component;
     }
@@ -1263,26 +1235,27 @@ bool PackageManagerCore::calculateComponentsToInstall() const
     emit aboutCalculateComponentsToInstall();
     if (!d->m_componentsToInstallCalculated) {
         d->clearInstallerCalculator();
-        QList<Component*> components;
+        QList<Component*> componentsToInstall;
+        const QList<Component*> relevant = components(ComponentType::Root | ComponentType::Descendants);
         if (isUpdater()) {
-            foreach (Component *component, updaterComponents()) {
+            foreach (Component *component, relevant) {
                 if (component->updateRequested())
-                    components.append(component);
+                    componentsToInstall.append(component);
             }
         } else if (!isUpdater()) {
             // relevant means all components which are not replaced
-            const QList<Component*> relevantComponents = rootAndChildComponents();
-            foreach (Component *component, relevantComponents) {
+            foreach (Component *component, relevant) {
                 // ask for all components which will be installed to get all dependencies
                 // even dependencies which are changed without an increased version
                 if (component->installationRequested() || (component->isInstalled()
                     && !component->uninstallationRequested())) {
-                        components.append(component);
+                    componentsToInstall.append(component);
                 }
             }
         }
 
-        d->m_componentsToInstallCalculated = d->installerCalculator()->appendComponentsToInstall(components);
+        d->m_componentsToInstallCalculated =
+            d->installerCalculator()->appendComponentsToInstall(componentsToInstall);
     }
     emit finishedCalculateComponentsToInstall();
     return d->m_componentsToInstallCalculated;
@@ -1312,14 +1285,14 @@ bool PackageManagerCore::calculateComponentsToUninstall() const
         // hack to avoid removing needed dependencies
         QSet<Component*>  componentsToInstall = d->installerCalculator()->orderedComponentsToInstall().toSet();
 
-        QList<Component*> components;
-        foreach (Component *component, availableComponents()) {
+        QList<Component*> componentsToUninstall;
+        foreach (Component *component, components(ComponentType::All)) {
             if (component->uninstallationRequested() && !componentsToInstall.contains(component))
-                components.append(component);
+                componentsToUninstall.append(component);
         }
 
         d->m_componentsToUninstall.clear();
-        result = d->appendComponentsToUninstall(components);
+        result = d->appendComponentsToUninstall(componentsToUninstall);
     }
     emit finishedCalculateComponentsToUninstall();
     return result;
@@ -1354,13 +1327,16 @@ QString PackageManagerCore::installReason(Component *component) const
 */
 QList<Component*> PackageManagerCore::dependees(const Component *_component) const
 {
-    QList<Component*> dependees;
-    const QList<Component*> components = availableComponents();
-    if (!_component || components.isEmpty())
-        return dependees;
+    if (!_component)
+        return QList<Component *>();
+
+    const QList<QInstaller::Component *> availableComponents = components(ComponentType::All);
+    if (availableComponents.isEmpty())
+        return QList<Component *>();
 
     const QLatin1Char dash('-');
-    foreach (Component *component, components) {
+    QList<Component *> dependees;
+    foreach (Component *component, availableComponents) {
         const QStringList &dependencies = component->dependencies();
         foreach (const QString &dependency, dependencies) {
             // the last part is considered to be the version then
@@ -2050,7 +2026,7 @@ bool PackageManagerCore::runPackageUpdater()
 */
 void PackageManagerCore::languageChanged()
 {
-    foreach (Component *component, availableComponents())
+    foreach (Component *component, components(ComponentType::All))
         component->languageChanged();
 }
 
@@ -2384,25 +2360,25 @@ void PackageManagerCore::resetComponentsToUserCheckedState()
 
 void PackageManagerCore::updateDisplayVersions(const QString &displayKey)
 {
-    QHash<QString, QInstaller::Component *> components;
-    const QList<QInstaller::Component *> componentList = availableComponents();
-    foreach (QInstaller::Component *component, componentList)
-        components[component->name()] = component;
+    QHash<QString, QInstaller::Component *> componentsHash;
+    foreach (QInstaller::Component *component, components(ComponentType::All))
+        componentsHash[component->name()] = component;
 
     // set display version for all components in list
-    const QStringList &keys = components.keys();
+    const QStringList &keys = componentsHash.keys();
     foreach (const QString &key, keys) {
         QHash<QString, bool> visited;
-        if (components.value(key)->isInstalled()) {
-            components.value(key)->setValue(scDisplayVersion,
-                findDisplayVersion(key, components, scInstalledVersion, visited));
+        if (componentsHash.value(key)->isInstalled()) {
+            componentsHash.value(key)->setValue(scDisplayVersion,
+                findDisplayVersion(key, componentsHash, scInstalledVersion, visited));
         }
         visited.clear();
-        const QString displayVersionRemote = findDisplayVersion(key, components, scRemoteVersion, visited);
+        const QString displayVersionRemote = findDisplayVersion(key, componentsHash,
+            scRemoteVersion, visited);
         if (displayVersionRemote.isEmpty())
-            components.value(key)->setValue(displayKey, tr("invalid"));
+            componentsHash.value(key)->setValue(displayKey, tr("invalid"));
         else
-            components.value(key)->setValue(displayKey, displayVersionRemote);
+            componentsHash.value(key)->setValue(displayKey, displayVersionRemote);
     }
 
 }
diff --git a/src/libs/installer/packagemanagercore.h b/src/libs/installer/packagemanagercore.h
index 5e372d53e..c85c42d8e 100644
--- a/src/libs/installer/packagemanagercore.h
+++ b/src/libs/installer/packagemanagercore.h
@@ -101,6 +101,16 @@ public:
         End = 0xffff
     };
 
+    enum struct ComponentType {
+        Root = 0x1,
+        Descendants = 0x2,
+        Dependencies = 0x4,
+        Replacements = 0x8,
+        AllNoReplacements = (Root | Descendants | Dependencies),
+        All = (Root | Descendants | Dependencies | Replacements)
+    };
+    Q_DECLARE_FLAGS(ComponentTypes, ComponentType)
+
     static QFont virtualComponentsFont();
     static void setVirtualComponentsFont(const QFont &font);
 
@@ -187,19 +197,10 @@ public:
 
     // component handling
 
-    int rootComponentCount() const;
-    Component *rootComponent(int i) const;
-    QList<Component*> rootComponents() const;
     void appendRootComponent(Component *components);
-
-    QList<Component*> rootAndChildComponents() const;
-
-    Q_INVOKABLE int updaterComponentCount() const;
-    Component *updaterComponent(int i) const;
-    QList<Component*> updaterComponents() const;
     void appendUpdaterComponent(Component *components);
 
-    QList<Component*> availableComponents() const;
+    QList<Component *> components(ComponentTypes mask) const;
     Component *componentByName(const QString &identifier) const;
 
     Q_INVOKABLE bool calculateComponentsToInstall() const;
@@ -341,6 +342,7 @@ private:
     friend class ComponentSelectionPage;
     void resetComponentsToUserCheckedState();
 };
+Q_DECLARE_OPERATORS_FOR_FLAGS(PackageManagerCore::ComponentTypes)
 
 }
 
diff --git a/src/libs/installer/packagemanagercore_p.cpp b/src/libs/installer/packagemanagercore_p.cpp
index 3d963c468..200086217 100644
--- a/src/libs/installer/packagemanagercore_p.cpp
+++ b/src/libs/installer/packagemanagercore_p.cpp
@@ -280,9 +280,8 @@ bool InstallerCalculator::appendComponentsToInstall(const QList<Component *> &co
             return false;
     }
 
-    const QList<Component*> relevantComponentForAutoDependOn = m_publicManager->isUpdater()
-            ? m_privateManager->m_updaterComponents + m_privateManager->m_updaterComponentsDeps
-            : m_publicManager->rootAndChildComponents();
+    const QList<Component*> relevantComponentForAutoDependOn =
+        m_publicManager->components(PackageManagerCore::ComponentType::AllNoReplacements);
 
     QList<Component *> foundAutoDependOnList;
     // All regular dependencies are resolved. Now we are looking for auto depend on components.
@@ -2485,13 +2484,12 @@ OperationList PackageManagerCorePrivate::sortOperationsBasedOnComponentDependenc
         }
     }
 
-    // create the complete component graph
-    Graph<QString> componentGraph;
+    const QString empty;
     const QRegExp dash(QLatin1String("-.*"));
-    foreach (const Component* componentNode, m_core->availableComponents()) {
-        componentGraph.addNode(componentNode->name());
-        const QStringList dependencies = componentNode->dependencies().replaceInStrings(dash,QString());
-        componentGraph.addEdges(componentNode->name(), dependencies);
+    Graph<QString> componentGraph;  // create the complete component graph
+    foreach (const Component* node, m_core->components(PackageManagerCore::ComponentType::All)) {
+        componentGraph.addNode(node->name());
+        componentGraph.addEdges(node->name(), node->dependencies().replaceInStrings(dash, empty));
     }
 
     const QStringList resolvedComponents = componentGraph.sort();
diff --git a/src/libs/installer/packagemanagergui.cpp b/src/libs/installer/packagemanagergui.cpp
index cf4367d6f..fddef304a 100644
--- a/src/libs/installer/packagemanagergui.cpp
+++ b/src/libs/installer/packagemanagergui.cpp
@@ -988,7 +988,7 @@ bool IntroductionPage::validatePage()
         callControlScript(QLatin1String("UpdaterSelectedCallback"));
 
         if (m_updatesFetched) {
-            if (core->updaterComponents().count() <= 0)
+            if (core->components(QInstaller::PackageManagerCore::ComponentType::Root).count() <= 0)
                 setErrorMessage(QString::fromLatin1("<b>%1</b>").arg(tr("No updates available.")));
             else
                 setComplete(true);
diff --git a/src/libs/installer/scriptengine.cpp b/src/libs/installer/scriptengine.cpp
index 37610cfc9..2c66f389c 100644
--- a/src/libs/installer/scriptengine.cpp
+++ b/src/libs/installer/scriptengine.cpp
@@ -82,10 +82,10 @@ ScriptEngine::ScriptEngine(PackageManagerCore *core)
         global.setProperty(QLatin1String("installer"), m_engine.newQObject(core));
         connect(core, SIGNAL(guiObjectChanged(QObject*)), this, SLOT(setGuiQObject(QObject*)));
 
-        const QList<Component*> components = core->availableComponents();
-        QJSValue scriptComponentsObject = m_engine.newArray(components.count());
-        for (int i = 0; i < components.count(); ++i) {
-            Component *const component = components.at(i);
+        const QList<Component*> all = core->components(PackageManagerCore::ComponentType::All);
+        QJSValue scriptComponentsObject = m_engine.newArray(all.count());
+        for (int i = 0; i < all.count(); ++i) {
+            Component *const component = all.at(i);
             QQmlEngine::setObjectOwnership(component, QQmlEngine::CppOwnership);
             scriptComponentsObject.setProperty(i, newQObject(component));
         }