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

ProjectExplorer: Rename various items in the Toolchain class

Browse Source 
Change-Id: I544763d3b4d521f6bbed0dc5a767c15c49055a19
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
This commit is contained in:
hjk
2023-11-27 17:09:08 +01:00
parent 8bec598d4c
commit ddf39cd0dc
21 changed files with 85 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/plugins/android/androidtoolchain.cpp
View File

@@ -140,7 +140,7 @@ GccToolChain::DetectedAbisResult AndroidToolChain::detectSupportedAbis() const
AndroidToolchainFactory::AndroidToolchainFactory()
{
setDisplayName(Tr::tr("Android Clang"));
setSupportedToolChainType(Constants::ANDROID_TOOLCHAIN_TYPEID);
setSupportedToolchainType(Constants::ANDROID_TOOLCHAIN_TYPEID);
setSupportedLanguages({ProjectExplorer::Constants::CXX_LANGUAGE_ID});
setToolchainConstructor([] { return new AndroidToolChain; });
}

6
src/plugins/baremetal/iarewtoolchain.cpp
View File

@@ -413,7 +413,7 @@ public:
IarToolchainFactory()
{
setDisplayName(Tr::tr("IAREW"));
setSupportedToolChainType(Constants::IAREW_TOOLCHAIN_TYPEID);
setSupportedToolchainType(Constants::IAREW_TOOLCHAIN_TYPEID);
setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID,
ProjectExplorer::Constants::CXX_LANGUAGE_ID});
setToolchainConstructor([] { return new IarToolChain; });
@@ -421,7 +421,7 @@ public:
}
Toolchains autoDetect(const ToolchainDetector &detector) const final;
Toolchains detectForImport(const ToolChainDescription &tcd) const final;
Toolchains detectForImport(const ToolchainDescription &tcd) const final;
private:
Toolchains autoDetectToolchains(const Candidates &candidates,
@@ -507,7 +507,7 @@ Toolchains IarToolchainFactory::autoDetect(const ToolchainDetector &detector) co
return autoDetectToolchains(candidates, detector.alreadyKnown);
}
Toolchains IarToolchainFactory::detectForImport(const ToolChainDescription &tcd) const
Toolchains IarToolchainFactory::detectForImport(const ToolchainDescription &tcd) const
{
return { autoDetectToolchain({tcd.compilerPath, {}}, tcd.language) };
}

2
src/plugins/baremetal/keiltoolchain.cpp
View File

@@ -544,7 +544,7 @@ public:
KeilToolchainFactory()
{
setDisplayName(Tr::tr("KEIL"));
setSupportedToolChainType(Constants::KEIL_TOOLCHAIN_TYPEID);
setSupportedToolchainType(Constants::KEIL_TOOLCHAIN_TYPEID);
setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID,
ProjectExplorer::Constants::CXX_LANGUAGE_ID});
setToolchainConstructor([] { return new KeilToolChain; });

2
src/plugins/baremetal/sdcctoolchain.cpp
View File

@@ -306,7 +306,7 @@ public:
SdccToolchainFactory()
{
setDisplayName(Tr::tr("SDCC"));
setSupportedToolChainType(Constants::SDCC_TOOLCHAIN_TYPEID);
setSupportedToolchainType(Constants::SDCC_TOOLCHAIN_TYPEID);
setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID});
setToolchainConstructor([] { return new SdccToolChain; });
setUserCreatable(true);

16
src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp
View File

@@ -56,7 +56,7 @@ struct DirectoryData
QString toolset;
FilePath sysroot;
QtProjectImporter::QtVersionData qt;
QVector<ToolChainDescription> toolChains;
QVector<ToolchainDescription> toolChains;
};
static FilePaths scanDirectory(const FilePath &path, const QString &prefix)
@@ -464,9 +464,9 @@ static QMakeAndCMakePrefixPath qtInfoFromCMakeCache(const CMakeConfig &config,
return {qmakeLocation, resultedPrefixPath};
}
static QVector<ToolChainDescription> extractToolChainsFromCache(const CMakeConfig &config)
static QVector<ToolchainDescription> extractToolChainsFromCache(const CMakeConfig &config)
{
QVector<ToolChainDescription> result;
QVector<ToolchainDescription> result;
bool haveCCxxCompiler = false;
for (const CMakeConfigItem &i : config) {
if (!i.key.startsWith("CMAKE_") || !i.key.endsWith("_COMPILER"))
@@ -564,7 +564,7 @@ void updateConfigWithDirectoryData(CMakeConfig &config, const std::unique_ptr<Di
});
auto tcd = Utils::findOrDefault(data->toolChains,
[&language](const ToolChainDescription &t) {
[&language](const ToolchainDescription &t) {
return t.language == language;
});
@@ -933,7 +933,7 @@ bool CMakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
const bool compilersMatch = [k, data] {
const QList<Id> allLanguages = ToolchainManager::allLanguages();
for (const ToolChainDescription &tcd : data->toolChains) {
for (const ToolchainDescription &tcd : data->toolChains) {
if (!Utils::contains(allLanguages,
[&tcd](const Id &language) { return language == tcd.language; }))
continue;
@@ -946,7 +946,7 @@ bool CMakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
}();
const bool noCompilers = [k, data] {
const QList<Id> allLanguages = ToolchainManager::allLanguages();
for (const ToolChainDescription &tcd : data->toolChains) {
for (const ToolchainDescription &tcd : data->toolChains) {
if (!Utils::contains(allLanguages,
[&tcd](const Id &language) { return language == tcd.language; }))
continue;
@@ -995,7 +995,7 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
SysRootKitAspect::setSysRoot(k, data->sysroot);
for (const ToolChainDescription &cmtcd : data->toolChains) {
for (const ToolchainDescription &cmtcd : data->toolChains) {
const ToolChainData tcd = findOrCreateToolChains(cmtcd);
QTC_ASSERT(!tcd.tcs.isEmpty(), continue);
@@ -1197,7 +1197,7 @@ void CMakeProjectPlugin::testCMakeProjectImporterToolChain()
config.append(CMakeConfigItem(key.toUtf8(), value.toUtf8()));
}
const QVector<ToolChainDescription> tcs = extractToolChainsFromCache(config);
const QVector<ToolchainDescription> tcs = extractToolChainsFromCache(config);
QCOMPARE(tcs.count(), expectedLanguages.count());
for (int i = 0; i < tcs.count(); ++i) {
QCOMPARE(tcs.at(i).language, expectedLanguages.at(i));

4
src/plugins/mcusupport/mcupackage.cpp
View File

@@ -417,7 +417,7 @@ static Toolchain *armGccToolChain(const FilePath &path, Id language)
ToolchainFactory *gccFactory
= Utils::findOrDefault(ToolchainFactory::allToolchainFactories(),
[](ToolchainFactory *f) {
return f->supportedToolChainType()
return f->supportedToolchainType()
== ProjectExplorer::Constants::GCC_TOOLCHAIN_TYPEID;
});
if (gccFactory) {
@@ -444,7 +444,7 @@ static Toolchain *iarToolChain(const FilePath &path, Id language)
ToolchainFactory *iarFactory
= Utils::findOrDefault(ToolchainFactory::allToolchainFactories(),
[](ToolchainFactory *f) {
return f->supportedToolChainType()
return f->supportedToolchainType()
== BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID;
});
if (iarFactory) {

4
src/plugins/mcusupport/test/unittest.cpp
View File

@@ -214,7 +214,7 @@ void verifyIarToolchain(const McuToolChainPackagePtr &iarToolchainPackage)
{
ProjectExplorer::ToolchainFactory toolchainFactory;
Id iarId{BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID};
Toolchain *iarToolchain{ProjectExplorer::ToolchainFactory::createToolChain(iarId)};
Toolchain *iarToolchain{ProjectExplorer::ToolchainFactory::createToolchain(iarId)};
iarToolchain->setLanguage(cxxLanguageId);
ToolchainManager::registerToolchain(iarToolchain);
@@ -238,7 +238,7 @@ void verifyArmGccToolchain(const McuToolChainPackagePtr &armGccPackage, const QS
ProjectExplorer::ToolchainFactory toolchainFactory;
Id armGccId{ProjectExplorer::Constants::GCC_TOOLCHAIN_TYPEID};
Toolchain *armToolchain{ProjectExplorer::ToolchainFactory::createToolChain(armGccId)};
Toolchain *armToolchain{ProjectExplorer::ToolchainFactory::createToolchain(armGccId)};
armToolchain->setLanguage(cxxLanguageId);
ToolchainManager::registerToolchain(armToolchain);

4
src/plugins/nim/project/nimtoolchain.cpp
View File

@@ -206,7 +206,7 @@ std::unique_ptr<ToolchainConfigWidget> NimToolChain::createConfigurationWidget()
NimToolchainFactory::NimToolchainFactory()
{
setDisplayName(Tr::tr("Nim"));
setSupportedToolChainType(Constants::C_NIMTOOLCHAIN_TYPEID);
setSupportedToolchainType(Constants::C_NIMTOOLCHAIN_TYPEID);
setSupportedLanguages({Constants::C_NIMLANGUAGE_ID});
setToolchainConstructor([] { return new NimToolChain; });
setUserCreatable(true);
@@ -235,7 +235,7 @@ Toolchains NimToolchainFactory::autoDetect(const ToolchainDetector &detector) co
return result;
}
Toolchains NimToolchainFactory::detectForImport(const ToolChainDescription &tcd) const
Toolchains NimToolchainFactory::detectForImport(const ToolchainDescription &tcd) const
{
Toolchains result;
if (tcd.language == Constants::C_NIMLANGUAGE_ID) {

2
src/plugins/nim/project/nimtoolchain.h
View File

@@ -40,7 +40,7 @@ public:
NimToolchainFactory();
ProjectExplorer::Toolchains autoDetect(const ProjectExplorer::ToolchainDetector &detector) const final;
ProjectExplorer::Toolchains detectForImport(const ProjectExplorer::ToolChainDescription &tcd) const final;
ProjectExplorer::Toolchains detectForImport(const ProjectExplorer::ToolchainDescription &tcd) const final;
};
} // Nim

2
src/plugins/projectexplorer/customtoolchain.cpp
View File

@@ -561,7 +561,7 @@ std::unique_ptr<ToolchainConfigWidget> CustomToolChain::createConfigurationWidge
CustomToolchainFactory::CustomToolchainFactory()
{
setDisplayName(Tr::tr("Custom"));
setSupportedToolChainType(Constants::CUSTOM_TOOLCHAIN_TYPEID);
setSupportedToolchainType(Constants::CUSTOM_TOOLCHAIN_TYPEID);
setSupportsAllLanguages(true);
setToolchainConstructor([] { return new CustomToolChain; });
setUserCreatable(true);

16
src/plugins/projectexplorer/gcctoolchain.cpp
View File

@@ -1285,22 +1285,22 @@ public:
switch (subType) {
case GccToolChain::RealGcc:
setDisplayName(Tr::tr("GCC"));
setSupportedToolChainType(Constants::GCC_TOOLCHAIN_TYPEID);
setSupportedToolchainType(Constants::GCC_TOOLCHAIN_TYPEID);
setToolchainConstructor(&constructRealGccToolchain);
break;
case GccToolChain::Clang:
setDisplayName(Tr::tr("Clang"));
setSupportedToolChainType(Constants::CLANG_TOOLCHAIN_TYPEID);
setSupportedToolchainType(Constants::CLANG_TOOLCHAIN_TYPEID);
setToolchainConstructor(&constructClangToolchain);
break;
case GccToolChain::MinGW:
setDisplayName(Tr::tr("MinGW"));
setSupportedToolChainType(Constants::MINGW_TOOLCHAIN_TYPEID);
setSupportedToolchainType(Constants::MINGW_TOOLCHAIN_TYPEID);
setToolchainConstructor(&constructMinGWToolchain);
break;
case GccToolChain::LinuxIcc:
setDisplayName(Tr::tr("ICC"));
setSupportedToolChainType(Constants::LINUXICC_TOOLCHAIN_TYPEID);
setSupportedToolchainType(Constants::LINUXICC_TOOLCHAIN_TYPEID);
setToolchainConstructor(&constructLinuxIccToolchain);
break;
}
@@ -1309,7 +1309,7 @@ public:
}
Toolchains autoDetect(const ToolchainDetector &detector) const final;
Toolchains detectForImport(const ToolChainDescription &tcd) const final;
Toolchains detectForImport(const ToolchainDescription &tcd) const final;
private:
static Toolchains autoDetectToolchains(const FilePaths &compilerPaths,
@@ -1317,7 +1317,7 @@ private:
const Id requiredTypeId,
const Toolchains &known,
const GccToolChain::SubType subType);
static Toolchains autoDetectToolChain(const ToolChainDescription &tcd,
static Toolchains autoDetectToolChain(const ToolchainDescription &tcd,
const GccToolChain::SubType subType);
static Toolchains autoDetectSdkClangToolchain(const Toolchains &known);
@@ -1504,7 +1504,7 @@ Toolchains GccToolchainFactory::autoDetect(const ToolchainDetector &detector) co
return result;
}
Toolchains GccToolchainFactory::detectForImport(const ToolChainDescription &tcd) const
Toolchains GccToolchainFactory::detectForImport(const ToolchainDescription &tcd) const
{
Toolchains result;
@@ -1616,7 +1616,7 @@ Toolchains GccToolchainFactory::autoDetectToolchains(const FilePaths &compilerPa
return result;
}
Toolchains GccToolchainFactory::autoDetectToolChain(const ToolChainDescription &tcd,
Toolchains GccToolchainFactory::autoDetectToolChain(const ToolchainDescription &tcd,
GccToolChain::SubType subType)
{
Toolchains result;

4
src/plugins/projectexplorer/msvctoolchain.cpp
View File

@@ -1872,7 +1872,7 @@ public:
MsvcToolchainFactory()
{
setDisplayName(Tr::tr("MSVC"));
setSupportedToolChainType(Constants::MSVC_TOOLCHAIN_TYPEID);
setSupportedToolchainType(Constants::MSVC_TOOLCHAIN_TYPEID);
setSupportedLanguages({Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID});
setToolchainConstructor([] { return new MsvcToolChain(Constants::MSVC_TOOLCHAIN_TYPEID); });
}
@@ -2244,7 +2244,7 @@ public:
{
setDisplayName(Tr::tr("clang-cl"));
setSupportedLanguages({Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID});
setSupportedToolChainType(Constants::CLANG_CL_TOOLCHAIN_TYPEID);
setSupportedToolchainType(Constants::CLANG_CL_TOOLCHAIN_TYPEID);
setToolchainConstructor([] { return new ClangClToolChain; });
}

4
src/plugins/projectexplorer/projectimporter.cpp
View File

@@ -366,7 +366,7 @@ bool ProjectImporter::hasKitWithTemporaryData(Utils::Id id, const QVariant &data
});
}
static ProjectImporter::ToolChainData createToolChains(const ToolChainDescription &tcd)
static ProjectImporter::ToolChainData createToolChains(const ToolchainDescription &tcd)
{
ProjectImporter::ToolChainData data;
@@ -386,7 +386,7 @@ static ProjectImporter::ToolChainData createToolChains(const ToolChainDescriptio
}
ProjectImporter::ToolChainData
ProjectImporter::findOrCreateToolChains(const ToolChainDescription &tcd) const
ProjectImporter::findOrCreateToolChains(const ToolchainDescription &tcd) const
{
ToolChainData result;
result.tcs = ToolchainManager::toolchains([&tcd](const Toolchain *tc) {

2
src/plugins/projectexplorer/projectimporter.h
View File

@@ -87,7 +87,7 @@ protected:
// Does *any* kit feature the requested data yet?
bool hasKitWithTemporaryData(Utils::Id id, const QVariant &data) const;
ToolChainData findOrCreateToolChains(const ToolChainDescription &tcd) const;
ToolChainData findOrCreateToolChains(const ToolchainDescription &tcd) const;
private:
void markKitAsTemporary(Kit *k) const;

46
src/plugins/projectexplorer/toolchain.cpp
View File

@@ -30,20 +30,20 @@ const char CODE_MODEL_TRIPLE_KEY[] = "ExplicitCodeModelTargetTriple";
QList<ToolchainFactory *> &toolchainFactories()
{
static QList<ToolchainFactory *> theToolChainFactories;
return theToolChainFactories;
static QList<ToolchainFactory *> theToolchainFactories;
return theToolchainFactories;
}
// --------------------------------------------------------------------------
// ToolChainPrivate
// ToolchainPrivate
// --------------------------------------------------------------------------
class ToolChainPrivate
class ToolchainPrivate
{
public:
using Detection = Toolchain::Detection;
explicit ToolChainPrivate(Id typeId) :
explicit ToolchainPrivate(Id typeId) :
m_id(QUuid::createUuid().toByteArray()),
m_typeId(typeId),
m_predefinedMacrosCache(new Toolchain::MacrosCache::element_type()),
@@ -107,7 +107,7 @@ QString languageId(Language l)
return {};
}
} // namespace Deprecated::ToolChain
} // namespace Deprecated::Toolchain
using namespace Internal;
@@ -120,7 +120,7 @@ using namespace Internal;
// --------------------------------------------------------------------------
Toolchain::Toolchain(Id typeId) :
d(std::make_unique<ToolChainPrivate>(typeId))
d(std::make_unique<ToolchainPrivate>(typeId))
{
}
@@ -220,7 +220,7 @@ bool Toolchain::operator == (const Toolchain &tc) const
Toolchain *Toolchain::clone() const
{
for (ToolchainFactory *f : std::as_const(toolchainFactories())) {
if (f->supportedToolChainType() == d->m_typeId) {
if (f->supportedToolchainType() == d->m_typeId) {
Toolchain *tc = f->create();
QTC_ASSERT(tc, return nullptr);
Store data;
@@ -535,25 +535,25 @@ void Toolchain::setExplicitCodeModelTargetTriple(const QString &triple)
}
/*!
\class ProjectExplorer::ToolChainFactory
\brief The ToolChainFactory class creates tool chains from settings or
\class ProjectExplorer::ToolchainFactory
\brief The ToolchainFactory class creates tool chains from settings or
autodetects them.
*/
/*!
\fn QString ProjectExplorer::ToolChainFactory::displayName() const = 0
\fn QString ProjectExplorer::ToolchainFactory::displayName() const = 0
Contains the name used to display the name of the tool chain that will be
created.
*/
/*!
\fn QStringList ProjectExplorer::ToolChain::clangParserFlags(const QStringList &cxxflags) const = 0
\fn QStringList ProjectExplorer::Toolchain::clangParserFlags(const QStringList &cxxflags) const = 0
Converts tool chain specific flags to list flags that tune the libclang
parser.
*/
/*!
\fn bool ProjectExplorer::ToolChainFactory::canRestore(const Store &data)
\fn bool ProjectExplorer::ToolchainFactory::canRestore(const Store &data)
Used by the tool chain manager to restore user-generated tool chains.
*/
@@ -578,7 +578,7 @@ Toolchains ToolchainFactory::autoDetect(const ToolchainDetector &detector) const
return {};
}
Toolchains ToolchainFactory::detectForImport(const ToolChainDescription &tcd) const
Toolchains ToolchainFactory::detectForImport(const ToolchainDescription &tcd) const
{
Q_UNUSED(tcd)
return {};
@@ -633,12 +633,12 @@ void ToolchainFactory::autoDetectionToMap(Store &data, bool detected)
data.insert(AUTODETECT_KEY, detected);
}
Toolchain *ToolchainFactory::createToolChain(Id toolChainType)
Toolchain *ToolchainFactory::createToolchain(Id toolchainType)
{
for (ToolchainFactory *factory : std::as_const(toolchainFactories())) {
if (factory->m_supportedToolChainType == toolChainType) {
if (factory->m_supportedToolchainType == toolchainType) {
if (Toolchain *tc = factory->create()) {
tc->d->m_typeId = toolChainType;
tc->d->m_typeId = toolchainType;
return tc;
}
}
@@ -651,14 +651,14 @@ QList<Id> ToolchainFactory::supportedLanguages() const
return m_supportsAllLanguages ? ToolchainManager::allLanguages() : m_supportedLanguages;
}
Id ToolchainFactory::supportedToolChainType() const
Id ToolchainFactory::supportedToolchainType() const
{
return m_supportedToolChainType;
return m_supportedToolchainType;
}
void ToolchainFactory::setSupportedToolChainType(const Id &supportedToolChain)
void ToolchainFactory::setSupportedToolchainType(const Id &supportedToolchainType)
{
m_supportedToolChainType = supportedToolChain;
m_supportedToolchainType = supportedToolchainType;
}
void ToolchainFactory::setSupportedLanguages(const QList<Id> &supportedLanguages)
@@ -671,12 +671,12 @@ void ToolchainFactory::setSupportsAllLanguages(bool supportsAllLanguages)
m_supportsAllLanguages = supportsAllLanguages;
}
void ToolchainFactory::setToolchainConstructor(const ToolChainConstructor &toolchainContructor)
void ToolchainFactory::setToolchainConstructor(const ToolchainConstructor &toolchainContructor)
{
m_toolchainConstructor = toolchainContructor;
}
ToolchainFactory::ToolChainConstructor ToolchainFactory::toolchainConstructor() const
ToolchainFactory::ToolchainConstructor ToolchainFactory::toolchainConstructor() const
{
return m_toolchainConstructor;
}

30
src/plugins/projectexplorer/toolchain.h
View File

@@ -26,7 +26,7 @@ namespace Utils { class OutputLineParser; }
namespace ProjectExplorer {
namespace Internal { class ToolChainPrivate; }
namespace Internal { class ToolchainPrivate; }
namespace Deprecated {
// Deprecated in 4.3:
@@ -44,9 +44,9 @@ class GccToolChain;
class ToolchainConfigWidget;
class Kit;
namespace Internal { class ToolChainSettingsAccessor; }
namespace Internal { class ToolchainSettingsAccessor; }
class PROJECTEXPLORER_EXPORT ToolChainDescription
class PROJECTEXPLORER_EXPORT ToolchainDescription
{
public:
Utils::FilePath compilerPath;
@@ -54,7 +54,7 @@ public:
};
// --------------------------------------------------------------------------
// ToolChain (documentation inside)
// Toolchain (documentation inside)
// --------------------------------------------------------------------------
class PROJECTEXPLORER_EXPORT Toolchain : public Utils::AspectContainer
@@ -194,9 +194,9 @@ private:
Toolchain(const Toolchain &) = delete;
Toolchain &operator=(const Toolchain &) = delete;
const std::unique_ptr<Internal::ToolChainPrivate> d;
const std::unique_ptr<Internal::ToolchainPrivate> d;
friend class Internal::ToolChainSettingsAccessor;
friend class Internal::ToolchainSettingsAccessor;
friend class ToolchainFactory;
};
@@ -253,10 +253,10 @@ public:
static const QList<ToolchainFactory *> allToolchainFactories();
QString displayName() const { return m_displayName; }
Utils::Id supportedToolChainType() const;
Utils::Id supportedToolchainType() const;
virtual Toolchains autoDetect(const ToolchainDetector &detector) const;
virtual Toolchains detectForImport(const ToolChainDescription &tcd) const;
virtual Toolchains detectForImport(const ToolchainDescription &tcd) const;
virtual bool canCreate() const;
Toolchain *create() const;
@@ -267,7 +267,7 @@ public:
static Utils::Id typeIdFromMap(const Utils::Store &data);
static void autoDetectionToMap(Utils::Store &data, bool detected);
static Toolchain *createToolChain(Utils::Id toolChainType);
static Toolchain *createToolchain(Utils::Id toolchainType);
QList<Utils::Id> supportedLanguages() const;
@@ -275,12 +275,12 @@ public:
protected:
void setDisplayName(const QString &name) { m_displayName = name; }
void setSupportedToolChainType(const Utils::Id &supportedToolChainType);
void setSupportedToolchainType(const Utils::Id &supportedToolchainType);
void setSupportedLanguages(const QList<Utils::Id> &supportedLanguages);
void setSupportsAllLanguages(bool supportsAllLanguages);
using ToolChainConstructor = std::function<Toolchain *()>;
void setToolchainConstructor(const ToolChainConstructor &constructor);
ToolChainConstructor toolchainConstructor() const;
using ToolchainConstructor = std::function<Toolchain *()>;
void setToolchainConstructor(const ToolchainConstructor &constructor);
ToolchainConstructor toolchainConstructor() const;
class Candidate {
public:
@@ -297,11 +297,11 @@ protected:
private:
QString m_displayName;
Utils::Id m_supportedToolChainType;
Utils::Id m_supportedToolchainType;
QList<Utils::Id> m_supportedLanguages;
bool m_supportsAllLanguages = false;
bool m_userCreatable = false;
ToolChainConstructor m_toolchainConstructor;
ToolchainConstructor m_toolchainConstructor;
};
} // namespace ProjectExplorer

4
src/plugins/projectexplorer/toolchainmanager.cpp
View File

@@ -38,7 +38,7 @@ class ToolchainManagerPrivate
public:
~ToolchainManagerPrivate();
std::unique_ptr<ToolChainSettingsAccessor> m_accessor;
std::unique_ptr<ToolchainSettingsAccessor> m_accessor;
Toolchains m_toolChains; // prioritized List
BadToolchains m_badToolchains; // to be skipped when auto-detecting
@@ -104,7 +104,7 @@ void ToolchainManager::restoreToolchains()
{
NANOTRACE_SCOPE("ProjectExplorer", "ToolchainManager::restoreToolChains");
QTC_ASSERT(!d->m_accessor, return);
d->m_accessor = std::make_unique<Internal::ToolChainSettingsAccessor>();
d->m_accessor = std::make_unique<Internal::ToolchainSettingsAccessor>();
for (Toolchain *tc : d->m_accessor->restoreToolChains(Core::ICore::dialogParent()))
registerToolchain(tc);

12
src/plugins/projectexplorer/toolchainsettingsaccessor.cpp
View File

@@ -173,7 +173,7 @@ static ToolChainOperations mergeToolChainLists(const Toolchains &systemFileTcs,
// ToolChainSettingsAccessor:
// --------------------------------------------------------------------
ToolChainSettingsAccessor::ToolChainSettingsAccessor()
ToolchainSettingsAccessor::ToolchainSettingsAccessor()
{
setDocType("QtCreatorToolChains");
setApplicationDisplayName(QGuiApplication::applicationDisplayName());
@@ -182,7 +182,7 @@ ToolChainSettingsAccessor::ToolChainSettingsAccessor()
addVersionUpgrader(std::make_unique<ToolChainSettingsUpgraderV0>());
}
Toolchains ToolChainSettingsAccessor::restoreToolChains(QWidget *parent) const
Toolchains ToolchainSettingsAccessor::restoreToolChains(QWidget *parent) const
{
NANOTRACE_SCOPE("ProjectExplorer", "ToolChainSettingsAccessor::restoreToolChains");
// read all tool chains from SDK
@@ -218,7 +218,7 @@ Toolchains ToolChainSettingsAccessor::restoreToolChains(QWidget *parent) const
return ops.toRegister;
}
void ToolChainSettingsAccessor::saveToolChains(const Toolchains &toolchains, QWidget *parent)
void ToolchainSettingsAccessor::saveToolChains(const Toolchains &toolchains, QWidget *parent)
{
Store data;
@@ -240,7 +240,7 @@ void ToolChainSettingsAccessor::saveToolChains(const Toolchains &toolchains, QWi
saveSettings(data, parent);
}
Toolchains ToolChainSettingsAccessor::toolChains(const Store &data) const
Toolchains ToolchainSettingsAccessor::toolChains(const Store &data) const
{
Toolchains result;
const QList<ToolchainFactory *> factories = ToolchainFactory::allToolchainFactories();
@@ -257,7 +257,7 @@ Toolchains ToolChainSettingsAccessor::toolChains(const Store &data) const
const Utils::Id tcType = ToolchainFactory::typeIdFromMap(tcMap);
if (tcType.isValid()) {
for (ToolchainFactory *f : factories) {
if (f->supportedToolChainType() == tcType) {
if (f->supportedToolchainType() == tcType) {
if (Toolchain *tc = f->restore(tcMap)) {
result.append(tc);
restored = true;
@@ -360,7 +360,7 @@ void ProjectExplorerPlugin::testToolChainMerging_data()
{
public:
TestToolchainFactory() {
setSupportedToolChainType(TestToolChainType);
setSupportedToolchainType(TestToolChainType);
setToolchainConstructor([] { return new TTC; });
}
};

4
src/plugins/projectexplorer/toolchainsettingsaccessor.h
View File

@@ -13,10 +13,10 @@ class Toolchain;
namespace Internal {
class ToolChainSettingsAccessor : public Utils::UpgradingSettingsAccessor
class ToolchainSettingsAccessor : public Utils::UpgradingSettingsAccessor
{
public:
ToolChainSettingsAccessor();
ToolchainSettingsAccessor();
QList<Toolchain *> restoreToolChains(QWidget *parent) const;

2
src/plugins/qnx/qnxtoolchain.cpp
View File

@@ -259,7 +259,7 @@ public:
QnxToolchainFactory()
{
setDisplayName(Tr::tr("QCC"));
setSupportedToolChainType(Constants::QNX_TOOLCHAIN_ID);
setSupportedToolchainType(Constants::QNX_TOOLCHAIN_ID);
setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID,
ProjectExplorer::Constants::CXX_LANGUAGE_ID});
setToolchainConstructor([] { return new QnxToolChain; });

2
src/plugins/webassembly/webassemblytoolchain.cpp
View File

@@ -173,7 +173,7 @@ public:
WebAssemblyToolchainFactory()
{
setDisplayName(Tr::tr("Emscripten"));
setSupportedToolChainType(Constants::WEBASSEMBLY_TOOLCHAIN_TYPEID);
setSupportedToolchainType(Constants::WEBASSEMBLY_TOOLCHAIN_TYPEID);
setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID,
ProjectExplorer::Constants::CXX_LANGUAGE_ID});
setToolchainConstructor([] { return new WebAssemblyToolChain; });