feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

ProjectExplorer: Remove FolderNode::addNode taking a raw pointer

Browse Source 
Change-Id: I53b765d2c3e71889386c76425662bfcc47bdf582
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
This commit is contained in:
Tobias Hunger
2018-04-26 15:35:33 +02:00
parent 8bbe795c39
commit 6fbf0255eb
7 changed files with 73 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/plugins/cmakeprojectmanager/servermodereader.cpp
View File

@@ -264,9 +264,10 @@ static void addCMakeVFolder(FolderNode *base, const Utils::FileName &basePath, i
return; return;
FolderNode *folder = base; FolderNode *folder = base;
if (!displayName.isEmpty()) { if (!displayName.isEmpty()) {
folder = new VirtualFolderNode(basePath, priority); auto newFolder = std::make_unique<VirtualFolderNode>(basePath, priority);
folder->setDisplayName(displayName); newFolder->setDisplayName(displayName);
base->addNode(folder); folder = newFolder.get();
base->addNode(std::move(newFolder));
} }
folder->addNestedNodes(files); folder->addNestedNodes(files);
for (FolderNode *fn : folder->folderNodes()) for (FolderNode *fn : folder->folderNodes())
@@ -291,8 +292,7 @@ static void addCMakeInputs(FolderNode *root,
QList<FileNode *> &buildInputs, QList<FileNode *> &buildInputs,
QList<FileNode *> &rootInputs) QList<FileNode *> &rootInputs)
{ {
ProjectNode *cmakeVFolder = new CMakeInputsNode(root->filePath()); std::unique_ptr<ProjectNode> cmakeVFolder = std::make_unique<CMakeInputsNode>(root->filePath());
root->addNode(cmakeVFolder);
QSet<Utils::FileName> knownFiles; QSet<Utils::FileName> knownFiles;
root->forEachGenericNode([&knownFiles](const Node *n) { root->forEachGenericNode([&knownFiles](const Node *n) {
@@ -300,13 +300,15 @@ static void addCMakeInputs(FolderNode *root,
knownFiles.insert(n->filePath()); knownFiles.insert(n->filePath());
}); });
addCMakeVFolder(cmakeVFolder, sourceDir, 1000, QString(), removeKnownNodes(knownFiles, sourceInputs)); addCMakeVFolder(cmakeVFolder.get(), sourceDir, 1000, QString(), removeKnownNodes(knownFiles, sourceInputs));
addCMakeVFolder(cmakeVFolder, buildDir, 100, addCMakeVFolder(cmakeVFolder.get(), buildDir, 100,
QCoreApplication::translate("CMakeProjectManager::Internal::ServerModeReader", "<Build Directory>"), QCoreApplication::translate("CMakeProjectManager::Internal::ServerModeReader", "<Build Directory>"),
removeKnownNodes(knownFiles, buildInputs)); removeKnownNodes(knownFiles, buildInputs));
addCMakeVFolder(cmakeVFolder, Utils::FileName(), 10, addCMakeVFolder(cmakeVFolder.get(), Utils::FileName(), 10,
QCoreApplication::translate("CMakeProjectManager::Internal::ServerModeReader", "<Other Locations>"), QCoreApplication::translate("CMakeProjectManager::Internal::ServerModeReader", "<Other Locations>"),
removeKnownNodes(knownFiles, rootInputs)); removeKnownNodes(knownFiles, rootInputs));
root->addNode(std::move(cmakeVFolder));
} }
void ServerModeReader::generateProjectTree(CMakeProjectNode *root, void ServerModeReader::generateProjectTree(CMakeProjectNode *root,
@@ -751,8 +753,9 @@ static ProjectNode *createProjectNode(const QHash<Utils::FileName, ProjectNode *
CMakeProjectNode *pn = static_cast<CMakeProjectNode *>(cmln->projectNode(projectName)); CMakeProjectNode *pn = static_cast<CMakeProjectNode *>(cmln->projectNode(projectName));
if (!pn) { if (!pn) {
pn = new CMakeProjectNode(projectName); auto newNode = std::make_unique<CMakeProjectNode>(projectName);
cmln->addNode(pn); pn = newNode.get();
cmln->addNode(std::move(newNode));
} }
pn->setDisplayName(displayName); pn->setDisplayName(displayName);
return pn; return pn;
@@ -781,8 +784,9 @@ static CMakeTargetNode *createTargetNode(const QHash<Utils::FileName, ProjectNod
return n->id() == targetId; return n->id() == targetId;
})); }));
if (!tn) { if (!tn) {
tn = new CMakeTargetNode(dir, displayName); auto newNode = std::make_unique<CMakeTargetNode>(dir, displayName);
cmln->addNode(tn); tn = newNode.get();
cmln->addNode(std::move(newNode));
} }
tn->setDisplayName(displayName); tn->setDisplayName(displayName);
return tn; return tn;
@@ -885,7 +889,7 @@ void ServerModeReader::addHeaderNodes(ProjectNode *root, const QList<FileNode *>
return; return;
static QIcon headerNodeIcon = Core::FileIconProvider::directoryIcon(ProjectExplorer::Constants::FILEOVERLAY_H); static QIcon headerNodeIcon = Core::FileIconProvider::directoryIcon(ProjectExplorer::Constants::FILEOVERLAY_H);
auto headerNode = new VirtualFolderNode(root->filePath(), Node::DefaultPriority - 5); auto headerNode = std::make_unique<VirtualFolderNode>(root->filePath(), Node::DefaultPriority - 5);
headerNode->setDisplayName(tr("<Headers>")); headerNode->setDisplayName(tr("<Headers>"));
headerNode->setIcon(headerNodeIcon); headerNode->setIcon(headerNodeIcon);
@@ -905,10 +909,8 @@ void ServerModeReader::addHeaderNodes(ProjectNode *root, const QList<FileNode *>
} }
} }
if (headerNode->isEmpty()) if (!headerNode->isEmpty())
delete headerNode; // No Headers, do not show this Folder. root->addNode(std::move(headerNode));
else
root->addNode(headerNode);
} }
} // namespace Internal } // namespace Internal

15
src/plugins/projectexplorer/projectnodes.cpp
View File

@@ -560,11 +560,8 @@ void FolderNode::addNestedNode(std::unique_ptr<FileNode> &&fileNode,
void FolderNode::addNestedNodes(const QList<FileNode *> &files, const Utils::FileName &overrideBaseDir, void FolderNode::addNestedNodes(const QList<FileNode *> &files, const Utils::FileName &overrideBaseDir,
const FolderNodeFactory &factory) const FolderNodeFactory &factory)
{ {
for (FileNode *fileNode : files) { for (FileNode *fileNode : files)
FolderNode *folder = recursiveFindOrCreateFolderNode(this, fileNode->filePath().parentDir(), addNestedNode(std::unique_ptr<FileNode>(fileNode), overrideBaseDir, factory);
overrideBaseDir, factory);
folder->addNode(fileNode);
}
} }
// "Compress" a tree of foldernodes such that foldernodes with exactly one foldernode as a child // "Compress" a tree of foldernodes such that foldernodes with exactly one foldernode as a child
@@ -712,14 +709,6 @@ FolderNode::AddNewInformation FolderNode::addNewInformation(const QStringList &f
Adds a node specified by \a node to the internal list of nodes. Adds a node specified by \a node to the internal list of nodes.
*/ */
void FolderNode::addNode(Node *node)
{
QTC_ASSERT(node, return);
QTC_ASSERT(!node->parentFolderNode(), qDebug("Node has already a parent folder"));
node->setParentFolderNode(this);
m_nodes.emplace_back(std::unique_ptr<Node>(node));
}
void FolderNode::addNode(std::unique_ptr<Node> &&node) void FolderNode::addNode(std::unique_ptr<Node> &&node)
{ {
QTC_ASSERT(node, return); QTC_ASSERT(node, return);

1
src/plugins/projectexplorer/projectnodes.h
View File

@@ -282,7 +282,6 @@ public:
// determines if node will always be shown when hiding empty directories // determines if node will always be shown when hiding empty directories
virtual bool showWhenEmpty() const; virtual bool showWhenEmpty() const;
void addNode(Node *node);
void addNode(std::unique_ptr<Node> &&node); void addNode(std::unique_ptr<Node> &&node);
std::unique_ptr<Node> takeNode(Node *node); std::unique_ptr<Node> takeNode(Node *node);

51
src/plugins/qbsprojectmanager/qbsnodetreebuilder.cpp
View File

@@ -80,23 +80,23 @@ void setupArtifacts(ProjectExplorer::FolderNode *root, const QList<qbs::Artifact
root->compress(); root->compress();
} }
QbsProjectManager::Internal::QbsGroupNode std::unique_ptr<QbsProjectManager::Internal::QbsGroupNode>
*buildGroupNodeTree(const qbs::GroupData &grp, const QString &productPath, bool productIsEnabled) buildGroupNodeTree(const qbs::GroupData &grp, const QString &productPath, bool productIsEnabled)
{ {
QTC_ASSERT(grp.isValid(), return nullptr); QTC_ASSERT(grp.isValid(), return nullptr);
auto result = new QbsProjectManager::Internal::QbsGroupNode(grp, productPath); auto result = std::make_unique<QbsProjectManager::Internal::QbsGroupNode>(grp, productPath);
result->setEnabled(productIsEnabled && grp.isEnabled()); result->setEnabled(productIsEnabled && grp.isEnabled());
result->setAbsoluteFilePathAndLine( result->setAbsoluteFilePathAndLine(
Utils::FileName::fromString(grp.location().filePath()).parentDir(), -1); Utils::FileName::fromString(grp.location().filePath()).parentDir(), -1);
result->setDisplayName(grp.name()); result->setDisplayName(grp.name());
result->addNode(new QbsProjectManager::Internal::QbsFileNode( result->addNode(std::make_unique<QbsProjectManager::Internal::QbsFileNode>(
Utils::FileName::fromString(grp.location().filePath()), Utils::FileName::fromString(grp.location().filePath()),
ProjectExplorer::FileType::Project, false, ProjectExplorer::FileType::Project, false,
grp.location().line())); grp.location().line()));
::setupArtifacts(result, grp.allSourceArtifacts()); ::setupArtifacts(result.get(), grp.allSourceArtifacts());
return result; return result;
} }
@@ -113,9 +113,9 @@ void setupQbsProductData(QbsProjectManager::Internal::QbsProductNode *node,
const QString &productPath = QFileInfo(prd.location().filePath()).absolutePath(); const QString &productPath = QFileInfo(prd.location().filePath()).absolutePath();
// Add QbsFileNode: // Add QbsFileNode:
node->addNode(new QbsFileNode(Utils::FileName::fromString(prd.location().filePath()), node->addNode(std::make_unique<QbsFileNode>(Utils::FileName::fromString(prd.location().filePath()),
ProjectExplorer::FileType::Project, false, ProjectExplorer::FileType::Project, false,
prd.location().line())); prd.location().line()));
foreach (const qbs::GroupData &grp, prd.groups()) { foreach (const qbs::GroupData &grp, prd.groups()) {
@@ -129,18 +129,19 @@ void setupQbsProductData(QbsProjectManager::Internal::QbsProductNode *node,
// Add "Generated Files" Node: // Add "Generated Files" Node:
auto genFiles auto genFiles
= new ProjectExplorer::VirtualFolderNode(node->filePath(), = std::make_unique<ProjectExplorer::VirtualFolderNode>(node->filePath(),
ProjectExplorer::Node::DefaultProjectFilePriority - 10); ProjectExplorer::Node::DefaultProjectFilePriority - 10);
genFiles->setDisplayName(QCoreApplication::translate("QbsProductNode", "Generated files")); genFiles->setDisplayName(QCoreApplication::translate("QbsProductNode", "Generated files"));
node->addNode(genFiles); setupArtifacts(genFiles.get(), prd.generatedArtifacts());
setupArtifacts(genFiles, prd.generatedArtifacts()); node->addNode(std::move(genFiles));
} }
QbsProjectManager::Internal::QbsProductNode *buildProductNodeTree(const qbs::ProductData &prd) std::unique_ptr<QbsProjectManager::Internal::QbsProductNode>
buildProductNodeTree(const qbs::ProductData &prd)
{ {
auto result = new QbsProjectManager::Internal::QbsProductNode(prd); auto result = std::make_unique<QbsProjectManager::Internal::QbsProductNode>(prd);
setupQbsProductData(result, prd); setupQbsProductData(result.get(), prd);
return result; return result;
} }
@@ -148,15 +149,15 @@ void setupProjectNode(QbsProjectManager::Internal::QbsProjectNode *node, const q
const qbs::Project &qbsProject) const qbs::Project &qbsProject)
{ {
using namespace QbsProjectManager::Internal; using namespace QbsProjectManager::Internal;
node->addNode(new QbsFileNode(Utils::FileName::fromString(prjData.location().filePath()), node->addNode(std::make_unique<QbsFileNode>(Utils::FileName::fromString(prjData.location().filePath()),
ProjectExplorer::FileType::Project, false, ProjectExplorer::FileType::Project, false,
prjData.location().line())); prjData.location().line()));
foreach (const qbs::ProjectData &subData, prjData.subProjects()) { foreach (const qbs::ProjectData &subData, prjData.subProjects()) {
auto subProject = auto subProject =
new QbsProjectManager::Internal::QbsProjectNode( std::make_unique<QbsProjectManager::Internal::QbsProjectNode>(
Utils::FileName::fromString(subData.location().filePath()).parentDir()); Utils::FileName::fromString(subData.location().filePath()).parentDir());
setupProjectNode(subProject, subData, qbsProject); setupProjectNode(subProject.get(), subData, qbsProject);
node->addNode(subProject); node->addNode(std::move(subProject));
} }
foreach (const qbs::ProductData &prd, prjData.products()) foreach (const qbs::ProductData &prd, prjData.products())
@@ -212,9 +213,9 @@ std::unique_ptr<QbsRootProjectNode> QbsNodeTreeBuilder::buildTree(QbsProject *pr
auto root = std::make_unique<QbsRootProjectNode>(project); auto root = std::make_unique<QbsRootProjectNode>(project);
setupProjectNode(root.get(), project->qbsProjectData(), project->qbsProject()); setupProjectNode(root.get(), project->qbsProjectData(), project->qbsProject());
auto buildSystemFiles auto buildSystemFiles
= new ProjectExplorer::FolderNode(project->projectDirectory(), = std::make_unique<ProjectExplorer::FolderNode>(project->projectDirectory(),
ProjectExplorer::NodeType::Folder, ProjectExplorer::NodeType::Folder,
QCoreApplication::translate("QbsRootProjectNode", "Qbs files")); QCoreApplication::translate("QbsRootProjectNode", "Qbs files"));
Utils::FileName base = project->projectDirectory(); Utils::FileName base = project->projectDirectory();
const QStringList &files = unreferencedBuildSystemFiles(project->qbsProject()); const QStringList &files = unreferencedBuildSystemFiles(project->qbsProject());
@@ -224,7 +225,7 @@ std::unique_ptr<QbsRootProjectNode> QbsNodeTreeBuilder::buildTree(QbsProject *pr
buildSystemFiles->addNestedNode(std::make_unique<ProjectExplorer::FileNode>(filePath, ProjectExplorer::FileType::Project, false)); buildSystemFiles->addNestedNode(std::make_unique<ProjectExplorer::FileNode>(filePath, ProjectExplorer::FileType::Project, false));
} }
buildSystemFiles->compress(); buildSystemFiles->compress();
root->addNode(buildSystemFiles); root->addNode(std::move(buildSystemFiles));
return root; return root;
} }

19
src/plugins/qmakeprojectmanager/qmakenodetreebuilder.cpp
View File

@@ -137,7 +137,7 @@ static void createTree(const QmakePriFile *pri, QmakePriFileNode *node, const Fi
node->setIcon(qmakeStaticData()->projectIcon); node->setIcon(qmakeStaticData()->projectIcon);
// .pro/.pri-file itself: // .pro/.pri-file itself:
node->addNode(new FileNode(pri->filePath(), FileType::Project, false)); node->addNode(std::make_unique<FileNode>(pri->filePath(), FileType::Project, false));
// other normal files: // other normal files:
const QVector<QmakeStaticData::FileTypeData> &fileTypes = qmakeStaticData()->fileTypeData; const QVector<QmakeStaticData::FileTypeData> &fileTypes = qmakeStaticData()->fileTypeData;
@@ -148,7 +148,7 @@ static void createTree(const QmakePriFile *pri, QmakePriFileNode *node, const Fi
}); });
if (!newFilePaths.isEmpty()) { if (!newFilePaths.isEmpty()) {
auto vfolder = new VirtualFolderNode(pri->filePath().parentDir(), Node::DefaultVirtualFolderPriority - i); auto vfolder = std::make_unique<VirtualFolderNode>(pri->filePath().parentDir(), Node::DefaultVirtualFolderPriority - i);
vfolder->setIcon(fileTypes.at(i).icon); vfolder->setIcon(fileTypes.at(i).icon);
vfolder->setDisplayName(fileTypes.at(i).typeName); vfolder->setDisplayName(fileTypes.at(i).typeName);
vfolder->setAddFileFilter(fileTypes.at(i).addFileFilter); vfolder->setAddFileFilter(fileTypes.at(i).addFileFilter);
@@ -167,8 +167,7 @@ static void createTree(const QmakePriFile *pri, QmakePriFileNode *node, const Fi
int eid = vfs->idForFileName(file.toString(), QMakeVfs::VfsExact); int eid = vfs->idForFileName(file.toString(), QMakeVfs::VfsExact);
vfs->readFile(eid, &contents, &errorMessage); vfs->readFile(eid, &contents, &errorMessage);
} }
auto resourceNode = new ResourceEditor::ResourceTopLevelNode(file, false, contents, vfolder); vfolder->addNode(std::make_unique<ResourceEditor::ResourceTopLevelNode>(file, false, contents, vfolder.get()));
vfolder->addNode(resourceNode);
} }
} else { } else {
for (const FileName &fn : newFilePaths) { for (const FileName &fn : newFilePaths) {
@@ -181,19 +180,19 @@ static void createTree(const QmakePriFile *pri, QmakePriFileNode *node, const Fi
for (FolderNode *fn : vfolder->folderNodes()) for (FolderNode *fn : vfolder->folderNodes())
fn->compress(); fn->compress();
} }
node->addNode(vfolder); node->addNode(std::move(vfolder));
} }
} }
// Virtual folders: // Virtual folders:
for (QmakePriFile *c : pri->children()) { for (QmakePriFile *c : pri->children()) {
QmakePriFileNode *newNode = nullptr; std::unique_ptr<QmakePriFileNode> newNode;
if (auto pf = dynamic_cast<QmakeProFile *>(c)) if (auto pf = dynamic_cast<QmakeProFile *>(c))
newNode = new QmakeProFileNode(c->project(), c->filePath(), pf); newNode = std::make_unique<QmakeProFileNode>(c->project(), c->filePath(), pf);
else else
newNode = new QmakePriFileNode(c->project(), node->proFileNode(), c->filePath(), c); newNode = std::make_unique<QmakePriFileNode>(c->project(), node->proFileNode(), c->filePath(), c);
createTree(c, newNode, toExclude); createTree(c, newNode.get(), toExclude);
node->addNode(newNode); node->addNode(std::move(newNode));
} }
} }

10
src/plugins/qmlprofiler/tests/qmlprofilerdetailsrewriter_test.cpp
View File

@@ -53,15 +53,15 @@ public:
DummyProject(const Utils::FileName &file) : DummyProject(const Utils::FileName &file) :
ProjectExplorer::Project(QString(), file, {}) ProjectExplorer::Project(QString(), file, {})
{ {
ProjectExplorer::FileNode *fileNode auto fileNode
= new ProjectExplorer::FileNode(file, ProjectExplorer::FileType::Source, false); = std::make_unique<ProjectExplorer::FileNode>(file, ProjectExplorer::FileType::Source, false);
auto root = std::make_unique<DummyProjectNode>(file); auto root = std::make_unique<DummyProjectNode>(file);
root->addNode(fileNode); root->addNode(std::move(fileNode));
fileNode = new ProjectExplorer::FileNode( fileNode = std::make_unique<ProjectExplorer::FileNode>(
Utils::FileName::fromLatin1( Utils::FileName::fromLatin1(
":/qmlprofiler/tests/qmlprofilerdetailsrewriter_test.cpp"), ":/qmlprofiler/tests/qmlprofilerdetailsrewriter_test.cpp"),
ProjectExplorer::FileType::Source, false); ProjectExplorer::FileType::Source, false);
root->addNode(fileNode); root->addNode(std::move(fileNode));
setRootProjectNode(std::move(root)); setRootProjectNode(std::move(root));
} }

25
src/plugins/resourceeditor/resourcenode.cpp
View File

@@ -313,9 +313,9 @@ void ResourceTopLevelNode::addInternalNodes()
// ensure that we don't duplicate prefixes // ensure that we don't duplicate prefixes
PrefixFolderLang prefixId(prefix, QString(), lang); PrefixFolderLang prefixId(prefix, QString(), lang);
if (!folderNodes.contains(prefixId)) { if (!folderNodes.contains(prefixId)) {
FolderNode *fn = new ResourceFolderNode(file.prefix(i), file.lang(i), this); auto fn = std::make_unique<ResourceFolderNode>(file.prefix(i), file.lang(i), this);
addNode(fn); folderNodes.insert(prefixId, fn.get());
folderNodes.insert(prefixId, fn); addNode(std::move(fn));
} }
ResourceFolderNode *currentPrefixNode = static_cast<ResourceFolderNode*>(folderNodes[prefixId]); ResourceFolderNode *currentPrefixNode = static_cast<ResourceFolderNode*>(folderNodes[prefixId]);
@@ -357,19 +357,18 @@ void ResourceTopLevelNode::addInternalNodes()
= filePath().toFileInfo().absoluteDir().absoluteFilePath( = filePath().toFileInfo().absoluteDir().absoluteFilePath(
currentPathList.join(QLatin1Char('/'))); currentPathList.join(QLatin1Char('/')));
const FileName folderPath = FileName::fromString(absoluteFolderName); const FileName folderPath = FileName::fromString(absoluteFolderName);
FolderNode *newNode std::unique_ptr<FolderNode> newNode
= new SimpleResourceFolderNode(folderName, pathElement, = std::make_unique<SimpleResourceFolderNode>(folderName, pathElement,
prefix, lang, folderPath, prefix, lang, folderPath,
this, currentPrefixNode); this, currentPrefixNode);
folderNodes.insert(folderId, newNode); folderNodes.insert(folderId, newNode.get());
PrefixFolderLang thisPrefixId = prefixId; PrefixFolderLang thisPrefixId = prefixId;
if (!parentIsPrefix) if (!parentIsPrefix)
thisPrefixId = PrefixFolderLang(prefix, parentFolderName, lang); thisPrefixId = PrefixFolderLang(prefix, parentFolderName, lang);
FolderNode *fn = folderNodes[thisPrefixId]; FolderNode *fn = folderNodes[thisPrefixId];
QTC_CHECK(fn); if (QTC_GUARD(fn))
if (fn) fn->addNode(std::move(newNode));
fn->addNode(newNode);
} }
parentIsPrefix = false; parentIsPrefix = false;
parentFolderName = folderName; parentFolderName = folderName;
@@ -380,8 +379,8 @@ void ResourceTopLevelNode::addInternalNodes()
FolderNode *fn = folderNodes[folderId]; FolderNode *fn = folderNodes[folderId];
QTC_CHECK(fn); QTC_CHECK(fn);
if (fn) if (fn)
fn->addNode(new ResourceFileNode(FileName::fromString(fileName), fn->addNode(std::make_unique<ResourceFileNode>(FileName::fromString(fileName),
qrcPath, displayName)); qrcPath, displayName));
} }
} }
} }