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;
FolderNode *folder = base;
if (!displayName.isEmpty()) {
folder = new VirtualFolderNode(basePath, priority);
folder->setDisplayName(displayName);
base->addNode(folder);
auto newFolder = std::make_unique<VirtualFolderNode>(basePath, priority);
newFolder->setDisplayName(displayName);
folder = newFolder.get();
base->addNode(std::move(newFolder));
}
folder->addNestedNodes(files);
for (FolderNode *fn : folder->folderNodes())
@@ -291,8 +292,7 @@ static void addCMakeInputs(FolderNode *root,
QList<FileNode *> &buildInputs,
QList<FileNode *> &rootInputs)
{
ProjectNode *cmakeVFolder = new CMakeInputsNode(root->filePath());
root->addNode(cmakeVFolder);
std::unique_ptr<ProjectNode> cmakeVFolder = std::make_unique<CMakeInputsNode>(root->filePath());
QSet<Utils::FileName> knownFiles;
root->forEachGenericNode([&knownFiles](const Node *n) {
@@ -300,13 +300,15 @@ static void addCMakeInputs(FolderNode *root,
knownFiles.insert(n->filePath());
});
addCMakeVFolder(cmakeVFolder, sourceDir, 1000, QString(), removeKnownNodes(knownFiles, sourceInputs));
addCMakeVFolder(cmakeVFolder, buildDir, 100,
addCMakeVFolder(cmakeVFolder.get(), sourceDir, 1000, QString(), removeKnownNodes(knownFiles, sourceInputs));
addCMakeVFolder(cmakeVFolder.get(), buildDir, 100,
QCoreApplication::translate("CMakeProjectManager::Internal::ServerModeReader", "<Build Directory>"),
removeKnownNodes(knownFiles, buildInputs));
addCMakeVFolder(cmakeVFolder, Utils::FileName(), 10,
addCMakeVFolder(cmakeVFolder.get(), Utils::FileName(), 10,
QCoreApplication::translate("CMakeProjectManager::Internal::ServerModeReader", "<Other Locations>"),
removeKnownNodes(knownFiles, rootInputs));
root->addNode(std::move(cmakeVFolder));
}
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));
if (!pn) {
pn = new CMakeProjectNode(projectName);
cmln->addNode(pn);
auto newNode = std::make_unique<CMakeProjectNode>(projectName);
pn = newNode.get();
cmln->addNode(std::move(newNode));
}
pn->setDisplayName(displayName);
return pn;
@@ -781,8 +784,9 @@ static CMakeTargetNode *createTargetNode(const QHash<Utils::FileName, ProjectNod
return n->id() == targetId;
}));
if (!tn) {
tn = new CMakeTargetNode(dir, displayName);
cmln->addNode(tn);
auto newNode = std::make_unique<CMakeTargetNode>(dir, displayName);
tn = newNode.get();
cmln->addNode(std::move(newNode));
}
tn->setDisplayName(displayName);
return tn;
@@ -885,7 +889,7 @@ void ServerModeReader::addHeaderNodes(ProjectNode *root, const QList<FileNode *>
return;
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->setIcon(headerNodeIcon);
@@ -905,10 +909,8 @@ void ServerModeReader::addHeaderNodes(ProjectNode *root, const QList<FileNode *>
}
}
if (headerNode->isEmpty())
delete headerNode; // No Headers, do not show this Folder.
else
root->addNode(headerNode);
if (!headerNode->isEmpty())
root->addNode(std::move(headerNode));
}
} // 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,
const FolderNodeFactory &factory)
{
for (FileNode *fileNode : files) {
FolderNode *folder = recursiveFindOrCreateFolderNode(this, fileNode->filePath().parentDir(),
overrideBaseDir, factory);
folder->addNode(fileNode);
}
for (FileNode *fileNode : files)
addNestedNode(std::unique_ptr<FileNode>(fileNode), overrideBaseDir, factory);
}
// "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.
*/
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)
{
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
virtual bool showWhenEmpty() const;
void addNode(Node *node);
void addNode(std::unique_ptr<Node> &&node);
std::unique_ptr<Node> takeNode(Node *node);

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

@@ -80,23 +80,23 @@ void setupArtifacts(ProjectExplorer::FolderNode *root, const QList<qbs::Artifact
root->compress();
}
QbsProjectManager::Internal::QbsGroupNode
*buildGroupNodeTree(const qbs::GroupData &grp, const QString &productPath, bool productIsEnabled)
std::unique_ptr<QbsProjectManager::Internal::QbsGroupNode>
buildGroupNodeTree(const qbs::GroupData &grp, const QString &productPath, bool productIsEnabled)
{
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->setAbsoluteFilePathAndLine(
Utils::FileName::fromString(grp.location().filePath()).parentDir(), -1);
result->setDisplayName(grp.name());
result->addNode(new QbsProjectManager::Internal::QbsFileNode(
result->addNode(std::make_unique<QbsProjectManager::Internal::QbsFileNode>(
Utils::FileName::fromString(grp.location().filePath()),
ProjectExplorer::FileType::Project, false,
grp.location().line()));
::setupArtifacts(result, grp.allSourceArtifacts());
::setupArtifacts(result.get(), grp.allSourceArtifacts());
return result;
}
@@ -113,7 +113,7 @@ void setupQbsProductData(QbsProjectManager::Internal::QbsProductNode *node,
const QString &productPath = QFileInfo(prd.location().filePath()).absolutePath();
// 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,
prd.location().line()));
@@ -129,18 +129,19 @@ void setupQbsProductData(QbsProjectManager::Internal::QbsProductNode *node,
// Add "Generated Files" Node:
auto genFiles
= new ProjectExplorer::VirtualFolderNode(node->filePath(),
= std::make_unique<ProjectExplorer::VirtualFolderNode>(node->filePath(),
ProjectExplorer::Node::DefaultProjectFilePriority - 10);
genFiles->setDisplayName(QCoreApplication::translate("QbsProductNode", "Generated files"));
node->addNode(genFiles);
setupArtifacts(genFiles, prd.generatedArtifacts());
setupArtifacts(genFiles.get(), 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;
}
@@ -148,15 +149,15 @@ void setupProjectNode(QbsProjectManager::Internal::QbsProjectNode *node, const q
const qbs::Project &qbsProject)
{
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,
prjData.location().line()));
foreach (const qbs::ProjectData &subData, prjData.subProjects()) {
auto subProject =
new QbsProjectManager::Internal::QbsProjectNode(
std::make_unique<QbsProjectManager::Internal::QbsProjectNode>(
Utils::FileName::fromString(subData.location().filePath()).parentDir());
setupProjectNode(subProject, subData, qbsProject);
node->addNode(subProject);
setupProjectNode(subProject.get(), subData, qbsProject);
node->addNode(std::move(subProject));
}
foreach (const qbs::ProductData &prd, prjData.products())
@@ -212,7 +213,7 @@ std::unique_ptr<QbsRootProjectNode> QbsNodeTreeBuilder::buildTree(QbsProject *pr
auto root = std::make_unique<QbsRootProjectNode>(project);
setupProjectNode(root.get(), project->qbsProjectData(), project->qbsProject());
auto buildSystemFiles
= new ProjectExplorer::FolderNode(project->projectDirectory(),
= std::make_unique<ProjectExplorer::FolderNode>(project->projectDirectory(),
ProjectExplorer::NodeType::Folder,
QCoreApplication::translate("QbsRootProjectNode", "Qbs files"));
@@ -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->compress();
root->addNode(buildSystemFiles);
root->addNode(std::move(buildSystemFiles));
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);
// .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:
const QVector<QmakeStaticData::FileTypeData> &fileTypes = qmakeStaticData()->fileTypeData;
@@ -148,7 +148,7 @@ static void createTree(const QmakePriFile *pri, QmakePriFileNode *node, const Fi
});
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->setDisplayName(fileTypes.at(i).typeName);
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);
vfs->readFile(eid, &contents, &errorMessage);
}
auto resourceNode = new ResourceEditor::ResourceTopLevelNode(file, false, contents, vfolder);
vfolder->addNode(resourceNode);
vfolder->addNode(std::make_unique<ResourceEditor::ResourceTopLevelNode>(file, false, contents, vfolder.get()));
}
} else {
for (const FileName &fn : newFilePaths) {
@@ -181,19 +180,19 @@ static void createTree(const QmakePriFile *pri, QmakePriFileNode *node, const Fi
for (FolderNode *fn : vfolder->folderNodes())
fn->compress();
}
node->addNode(vfolder);
node->addNode(std::move(vfolder));
}
}
// Virtual folders:
for (QmakePriFile *c : pri->children()) {
QmakePriFileNode *newNode = nullptr;
std::unique_ptr<QmakePriFileNode> newNode;
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
newNode = new QmakePriFileNode(c->project(), node->proFileNode(), c->filePath(), c);
createTree(c, newNode, toExclude);
node->addNode(newNode);
newNode = std::make_unique<QmakePriFileNode>(c->project(), node->proFileNode(), c->filePath(), c);
createTree(c, newNode.get(), toExclude);
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) :
ProjectExplorer::Project(QString(), file, {})
{
ProjectExplorer::FileNode *fileNode
= new ProjectExplorer::FileNode(file, ProjectExplorer::FileType::Source, false);
auto fileNode
= std::make_unique<ProjectExplorer::FileNode>(file, ProjectExplorer::FileType::Source, false);
auto root = std::make_unique<DummyProjectNode>(file);
root->addNode(fileNode);
fileNode = new ProjectExplorer::FileNode(
root->addNode(std::move(fileNode));
fileNode = std::make_unique<ProjectExplorer::FileNode>(
Utils::FileName::fromLatin1(
":/qmlprofiler/tests/qmlprofilerdetailsrewriter_test.cpp"),
ProjectExplorer::FileType::Source, false);
root->addNode(fileNode);
root->addNode(std::move(fileNode));
setRootProjectNode(std::move(root));
}

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

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