CMake: Move some code out of the ServerModeReader

... so that it can get re-used in the to-be-written fileapi reader.

Change-Id: I2693e6bb102d910eb505882bf3468c34272a5d04
Reviewed-by: Tobias Hunger <tobias.hunger@qt.io>

src/plugins/cmakeprojectmanager/CMakeLists.txt

@@ -37,6 +37,7 @@ add_qtc_plugin(CMakeProjectManager
     cmaketoolsettingsaccessor.cpp cmaketoolsettingsaccessor.h
     configmodel.cpp configmodel.h
     configmodelitemdelegate.cpp configmodelitemdelegate.h
+    projecttreehelper.cpp projecttreehelper.h
     servermode.cpp servermode.h
     servermodereader.cpp servermodereader.h
     tealeafreader.cpp tealeafreader.h

src/plugins/cmakeprojectmanager/cmakeprojectmanager.pro

@@ -34,6 +34,7 @@ HEADERS = builddirmanager.h \
     cmakespecificsettingspage.h \
     configmodel.h \
     configmodelitemdelegate.h \
+    projecttreehelper.h \
     servermode.h \
     servermodereader.h \
     tealeafreader.h
@@ -68,6 +69,7 @@ SOURCES = builddirmanager.cpp \
     cmakespecificsettingspage.cpp \
     configmodel.cpp \
     configmodelitemdelegate.cpp \
+    projecttreehelper.cpp \
     servermode.cpp \
     servermodereader.cpp \
     tealeafreader.cpp

src/plugins/cmakeprojectmanager/cmakeprojectmanager.qbs

@@ -84,6 +84,8 @@ QtcPlugin {
         "configmodel.h",
         "configmodelitemdelegate.cpp",
         "configmodelitemdelegate.h",
+        "projecttreehelper.cpp",
+        "projecttreehelper.h",
         "servermode.cpp",
         "servermode.h",
         "servermodereader.cpp",

src/plugins/cmakeprojectmanager/projecttreehelper.cpp

@@ -0,0 +1,204 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of Qt Creator.
+**
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+****************************************************************************/
+
+#include "projecttreehelper.h"
+
+#include <coreplugin/fileiconprovider.h>
+#include <projectexplorer/projectexplorerconstants.h>
+
+#include <utils/algorithm.h>
+#include <utils/qtcassert.h>
+
+using namespace ProjectExplorer;
+
+namespace CMakeProjectManager {
+namespace Internal {
+
+void addCMakeVFolder(FolderNode *base,
+                     const Utils::FilePath &basePath,
+                     int priority,
+                     const QString &displayName,
+                     std::vector<std::unique_ptr<FileNode>> &&files)
+{
+    if (files.size() == 0)
+        return;
+    FolderNode *folder = base;
+    if (!displayName.isEmpty()) {
+        auto newFolder = std::make_unique<VirtualFolderNode>(basePath);
+        newFolder->setPriority(priority);
+        newFolder->setDisplayName(displayName);
+        folder = newFolder.get();
+        base->addNode(std::move(newFolder));
+    }
+    folder->addNestedNodes(std::move(files));
+    for (FolderNode *fn : folder->folderNodes())
+        fn->compress();
+}
+
+std::vector<std::unique_ptr<FileNode>> &&removeKnownNodes(
+    const QSet<Utils::FilePath> &knownFiles, std::vector<std::unique_ptr<FileNode>> &&files)
+{
+    Utils::erase(files, [&knownFiles](const std::unique_ptr<FileNode> &n) {
+        return knownFiles.contains(n->filePath());
+    });
+    return std::move(files);
+}
+
+void addCMakeInputs(FolderNode *root,
+                    const Utils::FilePath &sourceDir,
+                    const Utils::FilePath &buildDir,
+                    std::vector<std::unique_ptr<FileNode>> &&sourceInputs,
+                    std::vector<std::unique_ptr<FileNode>> &&buildInputs,
+                    std::vector<std::unique_ptr<FileNode>> &&rootInputs)
+{
+    std::unique_ptr<ProjectNode> cmakeVFolder = std::make_unique<CMakeInputsNode>(root->filePath());
+
+    QSet<Utils::FilePath> knownFiles;
+    root->forEachGenericNode([&knownFiles](const Node *n) {
+        if (n->listInProject())
+            knownFiles.insert(n->filePath());
+    });
+
+    addCMakeVFolder(cmakeVFolder.get(),
+                    sourceDir,
+                    1000,
+                    QString(),
+                    removeKnownNodes(knownFiles, std::move(sourceInputs)));
+    addCMakeVFolder(cmakeVFolder.get(),
+                    buildDir,
+                    100,
+                    QCoreApplication::translate("CMakeProjectManager::Internal::ServerModeReader",
+                                                "<Build Directory>"),
+                    removeKnownNodes(knownFiles, std::move(buildInputs)));
+    addCMakeVFolder(cmakeVFolder.get(),
+                    Utils::FilePath(),
+                    10,
+                    QCoreApplication::translate("CMakeProjectManager::Internal::ServerModeReader",
+                                                "<Other Locations>"),
+                    removeKnownNodes(knownFiles, std::move(rootInputs)));
+
+    root->addNode(std::move(cmakeVFolder));
+}
+QHash<Utils::FilePath, ProjectNode *> addCMakeLists(
+    CMakeProjectNode *root, std::vector<std::unique_ptr<FileNode>> &&cmakeLists)
+{
+    QHash<Utils::FilePath, ProjectNode *> cmakeListsNodes;
+    cmakeListsNodes.insert(root->filePath(), root);
+
+    const QSet<Utils::FilePath> cmakeDirs
+        = Utils::transform<QSet>(cmakeLists, [](const std::unique_ptr<FileNode> &n) {
+              return n->filePath().parentDir();
+          });
+    root->addNestedNodes(std::move(cmakeLists),
+                         Utils::FilePath(),
+                         [&cmakeDirs, &cmakeListsNodes](const Utils::FilePath &fp)
+                             -> std::unique_ptr<ProjectExplorer::FolderNode> {
+                             if (cmakeDirs.contains(fp)) {
+                                 auto fn = std::make_unique<CMakeListsNode>(fp);
+                                 cmakeListsNodes.insert(fp, fn.get());
+                                 return std::move(fn);
+                             }
+
+                             return std::make_unique<FolderNode>(fp);
+                         });
+    root->compress();
+    return cmakeListsNodes;
+}
+
+void createProjectNode(const QHash<Utils::FilePath, ProjectNode *> &cmakeListsNodes,
+                       const Utils::FilePath &dir,
+                       const QString &displayName)
+{
+    ProjectNode *cmln = cmakeListsNodes.value(dir);
+    QTC_ASSERT(cmln, return );
+
+    const Utils::FilePath projectName = dir.pathAppended(".project::" + displayName);
+
+    ProjectNode *pn = cmln->projectNode(projectName);
+    if (!pn) {
+        auto newNode = std::make_unique<CMakeProjectNode>(projectName);
+        pn = newNode.get();
+        cmln->addNode(std::move(newNode));
+    }
+    pn->setDisplayName(displayName);
+}
+
+CMakeTargetNode *createTargetNode(const QHash<Utils::FilePath, ProjectNode *> &cmakeListsNodes,
+                                  const Utils::FilePath &dir,
+                                  const QString &displayName)
+{
+    ProjectNode *cmln = cmakeListsNodes.value(dir);
+    QTC_ASSERT(cmln, return nullptr);
+
+    QString targetId = CMakeTargetNode::generateId(dir, displayName);
+
+    CMakeTargetNode *tn = static_cast<CMakeTargetNode *>(
+        cmln->findNode([&targetId](const Node *n) { return n->buildKey() == targetId; }));
+    if (!tn) {
+        auto newNode = std::make_unique<CMakeTargetNode>(dir, displayName);
+        tn = newNode.get();
+        cmln->addNode(std::move(newNode));
+    }
+    tn->setDisplayName(displayName);
+    return tn;
+}
+
+void addHeaderNodes(ProjectNode *root,
+                    const QList<FileNode *> knownHeaders,
+                    const QList<const FileNode *> &allFiles)
+{
+    if (root->isEmpty())
+        return;
+
+    static QIcon headerNodeIcon = Core::FileIconProvider::directoryIcon(
+        ProjectExplorer::Constants::FILEOVERLAY_H);
+    auto headerNode = std::make_unique<VirtualFolderNode>(root->filePath());
+    headerNode->setPriority(Node::DefaultPriority - 5);
+    headerNode->setDisplayName(
+        QCoreApplication::translate("CMakeProjectManager::Internal::ServerModeReader", "<Headers>"));
+    headerNode->setIcon(headerNodeIcon);
+
+    // knownHeaders are already listed in their targets:
+    QSet<Utils::FilePath> seenHeaders = Utils::transform<QSet>(knownHeaders, &FileNode::filePath);
+
+    // Add scanned headers:
+    for (const FileNode *fn : allFiles) {
+        if (fn->fileType() != FileType::Header || !fn->filePath().isChildOf(root->filePath()))
+            continue;
+        const int count = seenHeaders.count();
+        seenHeaders.insert(fn->filePath());
+        if (seenHeaders.count() != count) {
+            std::unique_ptr<FileNode> node(fn->clone());
+            node->setEnabled(false);
+            headerNode->addNestedNode(std::move(node));
+        }
+    }
+
+    if (!headerNode->isEmpty())
+        root->addNode(std::move(headerNode));
+}
+
+} // namespace Internal
+} // namespace CMakeProjectManager

src/plugins/cmakeprojectmanager/projecttreehelper.h

@@ -0,0 +1,70 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of Qt Creator.
+**
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+****************************************************************************/
+
+#include "cmakeprojectnodes.h"
+
+#include <projectexplorer/projectnodes.h>
+
+#include <utils/fileutils.h>
+
+#include <memory>
+
+namespace CMakeProjectManager {
+namespace Internal {
+
+void addCMakeVFolder(ProjectExplorer::FolderNode *base,
+                     const Utils::FilePath &basePath,
+                     int priority,
+                     const QString &displayName,
+                     std::vector<std::unique_ptr<ProjectExplorer::FileNode>> &&files);
+
+std::vector<std::unique_ptr<ProjectExplorer::FileNode>> &&removeKnownNodes(
+    const QSet<Utils::FilePath> &knownFiles,
+    std::vector<std::unique_ptr<ProjectExplorer::FileNode>> &&files);
+
+void addCMakeInputs(ProjectExplorer::FolderNode *root,
+                    const Utils::FilePath &sourceDir,
+                    const Utils::FilePath &buildDir,
+                    std::vector<std::unique_ptr<ProjectExplorer::FileNode>> &&sourceInputs,
+                    std::vector<std::unique_ptr<ProjectExplorer::FileNode>> &&buildInputs,
+                    std::vector<std::unique_ptr<ProjectExplorer::FileNode>> &&rootInputs);
+
+QHash<Utils::FilePath, ProjectExplorer::ProjectNode *> addCMakeLists(
+    CMakeProjectNode *root, std::vector<std::unique_ptr<ProjectExplorer::FileNode>> &&cmakeLists);
+
+void createProjectNode(const QHash<Utils::FilePath, ProjectExplorer::ProjectNode *> &cmakeListsNodes,
+                       const Utils::FilePath &dir,
+                       const QString &displayName);
+CMakeTargetNode *createTargetNode(
+    const QHash<Utils::FilePath, ProjectExplorer::ProjectNode *> &cmakeListsNodes,
+    const Utils::FilePath &dir,
+    const QString &displayName);
+
+void addHeaderNodes(ProjectExplorer::ProjectNode *root,
+                    const QList<ProjectExplorer::FileNode *> knownHeaders,
+                    const QList<const ProjectExplorer::FileNode *> &allFiles);
+
+} // namespace Internal
+} // namespace CMakeProjectManager

src/plugins/cmakeprojectmanager/servermodereader.cpp

@@ -30,9 +30,9 @@
 #include "cmakeprojectmanager.h"
 #include "cmakeprojectnodes.h"
 #include "servermode.h"
+#include "projecttreehelper.h"
 
 #include <coreplugin/editormanager/editormanager.h>
-#include <coreplugin/fileiconprovider.h>
 #include <coreplugin/messagemanager.h>
 #include <coreplugin/progressmanager/progressmanager.h>
 #include <projectexplorer/projectexplorerconstants.h>
@@ -227,61 +227,6 @@ CMakeConfig ServerModeReader::takeParsedConfiguration()
     return config;
 }
 
-static void addCMakeVFolder(FolderNode *base, const Utils::FilePath &basePath, int priority,
-                            const QString &displayName,
-                            std::vector<std::unique_ptr<FileNode>> &&files)
-{
-    if (files.size() == 0)
-        return;
-    FolderNode *folder = base;
-    if (!displayName.isEmpty()) {
-        auto newFolder = std::make_unique<VirtualFolderNode>(basePath);
-        newFolder->setPriority(priority);
-        newFolder->setDisplayName(displayName);
-        folder = newFolder.get();
-        base->addNode(std::move(newFolder));
-    }
-    folder->addNestedNodes(std::move(files));
-    for (FolderNode *fn : folder->folderNodes())
-        fn->compress();
-}
-
-static std::vector<std::unique_ptr<FileNode>> &&
-removeKnownNodes(const QSet<Utils::FilePath> &knownFiles,
-                 std::vector<std::unique_ptr<FileNode>> &&files)
-{
-    Utils::erase(files, [&knownFiles](const std::unique_ptr<FileNode> &n) {
-        return knownFiles.contains(n->filePath());
-    });
-    return std::move(files);
-}
-
-static void addCMakeInputs(FolderNode *root,
-                           const Utils::FilePath &sourceDir,
-                           const Utils::FilePath &buildDir,
-                           std::vector<std::unique_ptr<FileNode>> &&sourceInputs,
-                           std::vector<std::unique_ptr<FileNode>> &&buildInputs,
-                           std::vector<std::unique_ptr<FileNode>> &&rootInputs)
-{
-    std::unique_ptr<ProjectNode> cmakeVFolder = std::make_unique<CMakeInputsNode>(root->filePath());
-
-    QSet<Utils::FilePath> knownFiles;
-    root->forEachGenericNode([&knownFiles](const Node *n) {
-        if (n->listInProject())
-            knownFiles.insert(n->filePath());
-    });
-
-    addCMakeVFolder(cmakeVFolder.get(), sourceDir, 1000, QString(), removeKnownNodes(knownFiles, std::move(sourceInputs)));
-    addCMakeVFolder(cmakeVFolder.get(), buildDir, 100,
-                    QCoreApplication::translate("CMakeProjectManager::Internal::ServerModeReader", "<Build Directory>"),
-                    removeKnownNodes(knownFiles, std::move(buildInputs)));
-    addCMakeVFolder(cmakeVFolder.get(), Utils::FilePath(), 10,
-                    QCoreApplication::translate("CMakeProjectManager::Internal::ServerModeReader", "<Other Locations>"),
-                    removeKnownNodes(knownFiles, std::move(rootInputs)));
-
-    root->addNode(std::move(cmakeVFolder));
-}
-
 void ServerModeReader::generateProjectTree(CMakeProjectNode *root,
                                            const QList<const FileNode *> &allFiles)
 {
@@ -790,49 +735,6 @@ void ServerModeReader::fixTarget(ServerModeReader::Target *target) const
     }
 }
 
-QHash<Utils::FilePath, ProjectNode *>
-ServerModeReader::addCMakeLists(CMakeProjectNode *root,
-                                std::vector<std::unique_ptr<FileNode>> &&cmakeLists)
-{
-    QHash<Utils::FilePath, ProjectNode *> cmakeListsNodes;
-    cmakeListsNodes.insert(root->filePath(), root);
-
-    const QSet<Utils::FilePath> cmakeDirs
-            = Utils::transform<QSet>(cmakeLists, [](const std::unique_ptr<FileNode> &n) {
-        return n->filePath().parentDir();
-    });
-    root->addNestedNodes(std::move(cmakeLists), Utils::FilePath(),
-                         [&cmakeDirs, &cmakeListsNodes](const Utils::FilePath &fp)
-                         -> std::unique_ptr<ProjectExplorer::FolderNode> {
-        if (cmakeDirs.contains(fp)) {
-            auto fn = std::make_unique<CMakeListsNode>(fp);
-            cmakeListsNodes.insert(fp, fn.get());
-            return fn;
-        }
-
-        return std::make_unique<FolderNode>(fp);
-    });
-    root->compress();
-    return cmakeListsNodes;
-}
-
-static void createProjectNode(const QHash<Utils::FilePath, ProjectNode *> &cmakeListsNodes,
-                              const Utils::FilePath &dir, const QString &displayName)
-{
-    ProjectNode *cmln = cmakeListsNodes.value(dir);
-    QTC_ASSERT(cmln, qDebug() << dir.toUserOutput(); return);
-
-    const Utils::FilePath projectName = dir.pathAppended(".project::" + displayName);
-
-    ProjectNode *pn = cmln->projectNode(projectName);
-    if (!pn) {
-        auto newNode = std::make_unique<CMakeProjectNode>(projectName);
-        pn = newNode.get();
-        cmln->addNode(std::move(newNode));
-    }
-    pn->setDisplayName(displayName);
-}
-
 void ServerModeReader::addProjects(const QHash<Utils::FilePath, ProjectNode *> &cmakeListsNodes,
                                    const QList<Project *> &projects,
                                    QList<FileNode *> &knownHeaderNodes)
@@ -843,26 +745,6 @@ void ServerModeReader::addProjects(const QHash<Utils::FilePath, ProjectNode *> &
     }
 }
 
-static CMakeTargetNode *createTargetNode(const QHash<Utils::FilePath, ProjectNode *> &cmakeListsNodes,
-                                         const Utils::FilePath &dir, const QString &displayName)
-{
-    ProjectNode *cmln = cmakeListsNodes.value(dir);
-    QTC_ASSERT(cmln, return nullptr);
-
-    QString targetId = CMakeTargetNode::generateId(dir, displayName);
-
-    CMakeTargetNode *tn = static_cast<CMakeTargetNode *>(cmln->findNode([&targetId](const Node *n) {
-        return n->buildKey() == targetId;
-    }));
-    if (!tn) {
-        auto newNode = std::make_unique<CMakeTargetNode>(dir, displayName);
-        tn = newNode.get();
-        cmln->addNode(std::move(newNode));
-    }
-    tn->setDisplayName(displayName);
-    return tn;
-}
-
 void ServerModeReader::addTargets(const QHash<Utils::FilePath, ProjectExplorer::ProjectNode *> &cmakeListsNodes,
                                   const QList<Target *> &targets,
                                   QList<ProjectExplorer::FileNode *> &knownHeaderNodes)
@@ -955,39 +837,6 @@ void ServerModeReader::addFileGroups(ProjectNode *targetRoot,
     addCMakeVFolder(targetRoot, Utils::FilePath(), 10, tr("<Other Locations>"), std::move(otherFileNodes));
 }
 
-void ServerModeReader::addHeaderNodes(ProjectNode *root, const QList<FileNode *> knownHeaders,
-                                      const QList<const FileNode *> &allFiles)
-{
-    if (root->isEmpty())
-        return;
-
-    static QIcon headerNodeIcon
-            = Core::FileIconProvider::directoryIcon(ProjectExplorer::Constants::FILEOVERLAY_H);
-    auto headerNode = std::make_unique<VirtualFolderNode>(root->filePath());
-    headerNode->setPriority(Node::DefaultPriority - 5);
-    headerNode->setDisplayName(tr("<Headers>"));
-    headerNode->setIcon(headerNodeIcon);
-
-    // knownHeaders are already listed in their targets:
-    QSet<Utils::FilePath> seenHeaders = Utils::transform<QSet>(knownHeaders, &FileNode::filePath);
-
-    // Add scanned headers:
-    for (const FileNode *fn : allFiles) {
-        if (fn->fileType() != FileType::Header || !fn->filePath().isChildOf(root->filePath()))
-            continue;
-        const int count = seenHeaders.count();
-        seenHeaders.insert(fn->filePath());
-        if (seenHeaders.count() != count) {
-            std::unique_ptr<FileNode> node(fn->clone());
-            node->setEnabled(false);
-            headerNode->addNestedNode(std::move(node));
-        }
-    }
-
-    if (!headerNode->isEmpty())
-        root->addNode(std::move(headerNode));
-}
-
 } // namespace Internal
 } // namespace CMakeProjectManager
 

src/plugins/cmakeprojectmanager/servermodereader.h

@@ -145,8 +145,6 @@ private:
 
     void fixTarget(Target *target) const;
 
-    QHash<Utils::FilePath, ProjectExplorer::ProjectNode *>
-    addCMakeLists(CMakeProjectNode *root, std::vector<std::unique_ptr<ProjectExplorer::FileNode> > &&cmakeLists);
     void addProjects(const QHash<Utils::FilePath, ProjectExplorer::ProjectNode *> &cmakeListsNodes,
                      const QList<Project *> &projects,
                      QList<ProjectExplorer::FileNode *> &knownHeaderNodes);
@@ -158,10 +156,6 @@ private:
                        const Utils::FilePath &buildDirectory, const QList<FileGroup *> &fileGroups,
                        QList<ProjectExplorer::FileNode *> &knowHeaderNodes);
 
-    void addHeaderNodes(ProjectExplorer::ProjectNode *root,
-                        const QList<ProjectExplorer::FileNode *> knownHeaders,
-                        const QList<const ProjectExplorer::FileNode *> &allFiles);
-
     std::unique_ptr<ServerMode> m_cmakeServer;
     std::unique_ptr<QFutureInterface<void>> m_future;