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

ProjectExplorer: And more Key and Store

Browse Source 
Change-Id: Id5787890bdb46bfeef8e3f37923e6dc26cb56c31
Reviewed-by: Marcus Tillmanns <marcus.tillmanns@qt.io>
This commit is contained in:
hjk
2023-08-24 12:41:45 +02:00
parent 16454e13eb
commit 6c2864bd4b
27 changed files with 306 additions and 314 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/plugins/projectexplorer/buildconfiguration.cpp
View File

@@ -393,7 +393,7 @@ void BuildConfiguration::fromMap(const Store &map)
d->m_clearSystemEnvironment = map.value(QLatin1String(Constants::CLEAR_SYSTEM_ENVIRONMENT_KEY))
.toBool();
d->m_userEnvironmentChanges = EnvironmentItem::fromStringList(
map.value(QLatin1String(Constants::USER_ENVIRONMENT_CHANGES_KEY)).toStringList());
map.value(Constants::USER_ENVIRONMENT_CHANGES_KEY).toStringList());
updateCacheAndEmitEnvironmentChanged();
@@ -454,7 +454,7 @@ void BuildConfiguration::setConfigWidgetDisplayName(const QString &display)
d->m_configWidgetDisplayName = display;
}
void BuildConfiguration::setBuildDirectoryHistoryCompleter(const QString &history)
void BuildConfiguration::setBuildDirectoryHistoryCompleter(const Key &history)
{
d->m_buildDirectoryAspect.setHistoryCompleter(history);
}
@@ -464,7 +464,7 @@ void BuildConfiguration::setConfigWidgetHasFrame(bool configWidgetHasFrame)
d->m_configWidgetHasFrame = configWidgetHasFrame;
}
void BuildConfiguration::setBuildDirectorySettingsKey(const QString &key)
void BuildConfiguration::setBuildDirectorySettingsKey(const Key &key)
{
d->m_buildDirectoryAspect.setSettingsKey(key);
}
@@ -770,7 +770,7 @@ BuildConfiguration *BuildConfigurationFactory::create(Target *parent, const Buil
return bc;
}
BuildConfiguration *BuildConfigurationFactory::restore(Target *parent, const QVariantMap &map)
BuildConfiguration *BuildConfigurationFactory::restore(Target *parent, const Store &map)
{
const Utils::Id id = idFromMap(map);
for (BuildConfigurationFactory *factory : std::as_const(g_buildConfigurationFactories)) {
@@ -794,7 +794,7 @@ BuildConfiguration *BuildConfigurationFactory::restore(Target *parent, const QVa
BuildConfiguration *BuildConfigurationFactory::clone(Target *parent,
const BuildConfiguration *source)
{
QVariantMap map;
Store map;
source->toMap(map);
return restore(parent, map);
}

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

@@ -102,9 +102,9 @@ public:
ProjectExplorer::BuildDirectoryAspect *buildDirectoryAspect() const;
void setConfigWidgetDisplayName(const QString &display);
void setBuildDirectoryHistoryCompleter(const QString &history);
void setBuildDirectoryHistoryCompleter(const Utils::Key &history);
void setConfigWidgetHasFrame(bool configWidgetHasFrame);
void setBuildDirectorySettingsKey(const QString &key);
void setBuildDirectorySettingsKey(const Utils::Key &key);
void addConfigWidgets(const std::function<void (NamedWidget *)> &adder);

22
src/plugins/projectexplorer/customparser.cpp
View File

@@ -91,9 +91,9 @@ void CustomParserExpression::setMessageCap(int messageCap)
m_messageCap = messageCap;
}
QVariantMap CustomParserExpression::toMap() const
Store CustomParserExpression::toMap() const
{
QVariantMap map;
Store map;
map.insert(patternKey, pattern());
map.insert(messageCapKey, messageCap());
map.insert(fileNameCapKey, fileNameCap());
@@ -139,22 +139,22 @@ bool CustomParserSettings::operator ==(const CustomParserSettings &other) const
&& error == other.error && warning == other.warning;
}
QVariantMap CustomParserSettings::toMap() const
Store CustomParserSettings::toMap() const
{
QVariantMap map;
Store map;
map.insert(idKey, id.toSetting());
map.insert(nameKey, displayName);
map.insert(errorKey, error.toMap());
map.insert(warningKey, warning.toMap());
map.insert(errorKey, QVariant::fromValue(error.toMap()));
map.insert(warningKey, QVariant::fromValue(warning.toMap()));
return map;
}
void CustomParserSettings::fromMap(const Store &map)
{
id = Utils::Id::fromSetting(map.value(idKey));
id = Id::fromSetting(map.value(idKey));
displayName = map.value(nameKey).toString();
error.fromMap(map.value(errorKey).toMap());
warning.fromMap(map.value(warningKey).toMap());
error.fromMap(map.value(errorKey).value<Store>());
warning.fromMap(map.value(warningKey).value<Store>());
}
CustomParsersAspect::CustomParsersAspect(Target *target)
@@ -175,12 +175,12 @@ CustomParsersAspect::CustomParsersAspect(Target *target)
void CustomParsersAspect::fromMap(const Store &map)
{
m_parsers = transform(map.value(settingsKey()).toList(), &Utils::Id::fromSetting);
m_parsers = transform(map.value(settingsKey()).toList(), &Id::fromSetting);
}
void CustomParsersAspect::toMap(Store &map) const
{
map.insert(settingsKey(), transform(m_parsers, &Utils::Id::toSetting));
map.insert(settingsKey(), transform(m_parsers, &Id::toSetting));
}
namespace Internal {

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

@@ -274,13 +274,13 @@ QString CustomToolChain::mkspecs() const
void CustomToolChain::toMap(Store &data) const
{
ToolChain::toMap(data);
data.insert(QLatin1String(makeCommandKeyC), m_makeCommand.toString());
data.insert(makeCommandKeyC, m_makeCommand.toString());
QStringList macros = Utils::transform<QList>(m_predefinedMacros, [](const Macro &m) { return QString::fromUtf8(m.toByteArray()); });
data.insert(QLatin1String(predefinedMacrosKeyC), macros);
data.insert(QLatin1String(headerPathsKeyC), headerPathsList());
data.insert(QLatin1String(cxx11FlagsKeyC), m_cxx11Flags);
data.insert(QLatin1String(mkspecsKeyC), mkspecs());
data.insert(QLatin1String(outputParserKeyC), m_outputParserId.toSetting());
data.insert(predefinedMacrosKeyC, macros);
data.insert(headerPathsKeyC, headerPathsList());
data.insert(cxx11FlagsKeyC, m_cxx11Flags);
data.insert(mkspecsKeyC, mkspecs());
data.insert(outputParserKeyC, m_outputParserId.toSetting());
}
void CustomToolChain::fromMap(const Store &data)
@@ -289,13 +289,13 @@ void CustomToolChain::fromMap(const Store &data)
if (hasError())
return;
m_makeCommand = FilePath::fromString(data.value(QLatin1String(makeCommandKeyC)).toString());
const QStringList macros = data.value(QLatin1String(predefinedMacrosKeyC)).toStringList();
m_makeCommand = FilePath::fromString(data.value(makeCommandKeyC).toString());
const QStringList macros = data.value(predefinedMacrosKeyC).toStringList();
m_predefinedMacros = Macro::toMacros(macros.join('\n').toUtf8());
setHeaderPaths(data.value(QLatin1String(headerPathsKeyC)).toStringList());
m_cxx11Flags = data.value(QLatin1String(cxx11FlagsKeyC)).toStringList();
setMkspecs(data.value(QLatin1String(mkspecsKeyC)).toString());
setOutputParserId(Id::fromSetting(data.value(QLatin1String(outputParserKeyC))));
setHeaderPaths(data.value(headerPathsKeyC).toStringList());
m_cxx11Flags = data.value(cxx11FlagsKeyC).toStringList();
setMkspecs(data.value(mkspecsKeyC).toString());
setOutputParserId(Id::fromSetting(data.value(outputParserKeyC)));
}
bool CustomToolChain::operator ==(const ToolChain &other) const
@@ -441,9 +441,9 @@ CustomToolChainConfigWidget::CustomToolChainConfigWidget(CustomToolChain *tc) :
m_cxx11Flags->setToolTip(Tr::tr("Comma-separated list of flags that turn on C++11 support."));
m_mkspecs->setToolTip(Tr::tr("Comma-separated list of mkspecs."));
m_compilerCommand->setExpectedKind(PathChooser::ExistingCommand);
m_compilerCommand->setHistoryCompleter(QLatin1String("PE.ToolChainCommand.History"));
m_compilerCommand->setHistoryCompleter("PE.ToolChainCommand.History");
m_makeCommand->setExpectedKind(PathChooser::ExistingCommand);
m_makeCommand->setHistoryCompleter(QLatin1String("PE.MakeCommand.History"));
m_makeCommand->setHistoryCompleter("PE.MakeCommand.History");
m_mainLayout->addRow(Tr::tr("&Compiler path:"), m_compilerCommand);
m_mainLayout->addRow(Tr::tr("&Make path:"), m_makeCommand);
m_mainLayout->addRow(Tr::tr("&ABI:"), m_abiWidget);

32
src/plugins/projectexplorer/devicesupport/devicemanager.cpp
View File

@@ -130,8 +130,8 @@ void DeviceManager::save()
{
if (d->clonedInstance == this || !d->writer)
return;
QVariantMap data;
data.insert(QLatin1String(DeviceManagerKey), toMap());
Store data;
data.insert(DeviceManagerKey, QVariant::fromValue(toMap()));
d->writer->save(data, Core::ICore::dialogParent());
}
@@ -157,11 +157,11 @@ void DeviceManager::load()
QHash<Id, Id> defaultDevices;
QList<IDevice::Ptr> sdkDevices;
if (reader.load(systemSettingsFilePath("devices.xml")))
sdkDevices = fromMap(reader.restoreValues().value(DeviceManagerKey).toMap(), &defaultDevices);
sdkDevices = fromMap(reader.restoreValues().value(DeviceManagerKey).value<Store>(), &defaultDevices);
// read devices file from user settings path
QList<IDevice::Ptr> userDevices;
if (reader.load(settingsFilePath("devices.xml")))
userDevices = fromMap(reader.restoreValues().value(DeviceManagerKey).toMap(), &defaultDevices);
userDevices = fromMap(reader.restoreValues().value(DeviceManagerKey).value<Store>(), &defaultDevices);
// Insert devices into the model. Prefer the higher device version when there are multiple
// devices with the same id.
for (IDevice::ConstPtr device : std::as_const(userDevices)) {
@@ -189,7 +189,7 @@ void DeviceManager::load()
emit devicesLoaded();
}
static const IDeviceFactory *restoreFactory(const QVariantMap &map)
static const IDeviceFactory *restoreFactory(const Store &map)
{
const Id deviceType = IDevice::typeFromMap(map);
IDeviceFactory *factory = Utils::findOrDefault(IDeviceFactory::allDeviceFactories(),
@@ -209,13 +209,13 @@ QList<IDevice::Ptr> DeviceManager::fromMap(const Store &map, QHash<Id, Id> *defa
QList<IDevice::Ptr> devices;
if (defaultDevices) {
const QVariantMap defaultDevsMap = map.value(DefaultDevicesKey).toMap();
const Store defaultDevsMap = map.value(DefaultDevicesKey).value<Store>();
for (auto it = defaultDevsMap.constBegin(); it != defaultDevsMap.constEnd(); ++it)
defaultDevices->insert(Id::fromString(it.key()), Id::fromSetting(it.value()));
defaultDevices->insert(Id::fromString(stringFromKey(it.key())), Id::fromSetting(it.value()));
}
const QVariantList deviceList = map.value(QLatin1String(DeviceListKey)).toList();
const QVariantList deviceList = map.value(DeviceListKey).toList();
for (const QVariant &v : deviceList) {
const QVariantMap map = v.toMap();
const Store map = v.value<Store>();
const IDeviceFactory * const factory = restoreFactory(map);
if (!factory)
continue;
@@ -227,18 +227,18 @@ QList<IDevice::Ptr> DeviceManager::fromMap(const Store &map, QHash<Id, Id> *defa
return devices;
}
QVariantMap DeviceManager::toMap() const
Store DeviceManager::toMap() const
{
QVariantMap map;
QVariantMap defaultDeviceMap;
Store map;
Store defaultDeviceMap;
for (auto it = d->defaultDevices.constBegin(); it != d->defaultDevices.constEnd(); ++it)
defaultDeviceMap.insert(it.key().toString(), it.value().toSetting());
defaultDeviceMap.insert(keyFromString(it.key().toString()), it.value().toSetting());
map.insert(QLatin1String(DefaultDevicesKey), defaultDeviceMap);
map.insert(DefaultDevicesKey, QVariant::fromValue(defaultDeviceMap));
QVariantList deviceList;
for (const IDevice::Ptr &device : std::as_const(d->devices))
deviceList << device->toMap();
map.insert(QLatin1String(DeviceListKey), deviceList);
deviceList << QVariant::fromValue(device->toMap());
map.insert(DeviceListKey, deviceList);
return map;
}

75
src/plugins/projectexplorer/devicesupport/idevice.cpp
View File

@@ -422,12 +422,12 @@ void IDevice::setDeviceState(const IDevice::DeviceState state)
Id IDevice::typeFromMap(const Store &map)
{
return Id::fromSetting(map.value(QLatin1String(TypeKey)));
return Id::fromSetting(map.value(TypeKey));
}
Id IDevice::idFromMap(const Store &map)
{
return Id::fromSetting(map.value(QLatin1String(IdKey)));
return Id::fromSetting(map.value(IdKey));
}
/*!
@@ -440,20 +440,19 @@ void IDevice::fromMap(const Store &map)
{
d->type = typeFromMap(map);
d->displayName.fromMap(map, DisplayNameKey);
d->id = Id::fromSetting(map.value(QLatin1String(IdKey)));
d->osType = osTypeFromString(
map.value(QLatin1String(ClientOsTypeKey), osTypeToString(OsTypeLinux)).toString());
d->id = Id::fromSetting(map.value(IdKey));
d->osType = osTypeFromString(map.value(ClientOsTypeKey, osTypeToString(OsTypeLinux)).toString());
if (!d->id.isValid())
d->id = newId();
d->origin = static_cast<Origin>(map.value(QLatin1String(OriginKey), ManuallyAdded).toInt());
d->origin = static_cast<Origin>(map.value(OriginKey, ManuallyAdded).toInt());
QWriteLocker locker(&d->lock);
d->sshParameters.setHost(map.value(QLatin1String(HostKey)).toString());
d->sshParameters.setPort(map.value(QLatin1String(SshPortKey), 22).toInt());
d->sshParameters.setUserName(map.value(QLatin1String(UserNameKey)).toString());
d->sshParameters.setHost(map.value(HostKey).toString());
d->sshParameters.setPort(map.value(SshPortKey, 22).toInt());
d->sshParameters.setUserName(map.value(UserNameKey).toString());
// Pre-4.9, the authentication enum used to have more values
const int storedAuthType = map.value(QLatin1String(AuthKey), DefaultAuthType).toInt();
const int storedAuthType = map.value(AuthKey, DefaultAuthType).toInt();
const bool outdatedAuthType = storedAuthType
> SshParameters::AuthenticationTypeSpecificKey;
d->sshParameters.authenticationType = outdatedAuthType
@@ -461,22 +460,22 @@ void IDevice::fromMap(const Store &map)
: static_cast<AuthType>(storedAuthType);
d->sshParameters.privateKeyFile =
FilePath::fromSettings(map.value(QLatin1String(KeyFileKey), defaultPrivateKeyFilePath()));
d->sshParameters.timeout = map.value(QLatin1String(TimeoutKey), DefaultTimeout).toInt();
FilePath::fromSettings(map.value(KeyFileKey, defaultPrivateKeyFilePath()));
d->sshParameters.timeout = map.value(TimeoutKey, DefaultTimeout).toInt();
d->sshParameters.hostKeyCheckingMode = static_cast<SshHostKeyCheckingMode>
(map.value(QLatin1String(HostKeyCheckingKey), SshHostKeyCheckingNone).toInt());
(map.value(HostKeyCheckingKey, SshHostKeyCheckingNone).toInt());
QString portsSpec = map.value(PortsSpecKey).toString();
if (portsSpec.isEmpty())
portsSpec = "10000-10100";
d->freePorts = PortList::fromString(portsSpec);
d->machineType = static_cast<MachineType>(map.value(QLatin1String(MachineTypeKey), DefaultMachineType).toInt());
d->version = map.value(QLatin1String(VersionKey), 0).toInt();
d->machineType = static_cast<MachineType>(map.value(MachineTypeKey, DefaultMachineType).toInt());
d->version = map.value(VersionKey, 0).toInt();
d->debugServerPath = FilePath::fromSettings(map.value(QLatin1String(DebugServerKey)));
const FilePath qmlRunCmd = FilePath::fromSettings(map.value(QLatin1String(QmlRuntimeKey)));
d->debugServerPath = FilePath::fromSettings(map.value(DebugServerKey));
const FilePath qmlRunCmd = FilePath::fromSettings(map.value(QmlRuntimeKey));
d->qmlRunCommand = qmlRunCmd;
d->extraData = map.value(ExtraDataKey).toMap();
d->extraData = map.value(ExtraDataKey).value<Store>();
}
/*!
@@ -487,30 +486,30 @@ void IDevice::fromMap(const Store &map)
Store IDevice::toMap() const
{
QVariantMap map;
Store map;
d->displayName.toMap(map, DisplayNameKey);
map.insert(QLatin1String(TypeKey), d->type.toString());
map.insert(QLatin1String(ClientOsTypeKey), osTypeToString(d->osType));
map.insert(QLatin1String(IdKey), d->id.toSetting());
map.insert(QLatin1String(OriginKey), d->origin);
map.insert(TypeKey, d->type.toString());
map.insert(ClientOsTypeKey, osTypeToString(d->osType));
map.insert(IdKey, d->id.toSetting());
map.insert(OriginKey, d->origin);
QReadLocker locker(&d->lock);
map.insert(QLatin1String(MachineTypeKey), d->machineType);
map.insert(QLatin1String(HostKey), d->sshParameters.host());
map.insert(QLatin1String(SshPortKey), d->sshParameters.port());
map.insert(QLatin1String(UserNameKey), d->sshParameters.userName());
map.insert(QLatin1String(AuthKey), d->sshParameters.authenticationType);
map.insert(QLatin1String(KeyFileKey), d->sshParameters.privateKeyFile.toSettings());
map.insert(QLatin1String(TimeoutKey), d->sshParameters.timeout);
map.insert(QLatin1String(HostKeyCheckingKey), d->sshParameters.hostKeyCheckingMode);
map.insert(MachineTypeKey, d->machineType);
map.insert(HostKey, d->sshParameters.host());
map.insert(SshPortKey, d->sshParameters.port());
map.insert(UserNameKey, d->sshParameters.userName());
map.insert(AuthKey, d->sshParameters.authenticationType);
map.insert(KeyFileKey, d->sshParameters.privateKeyFile.toSettings());
map.insert(TimeoutKey, d->sshParameters.timeout);
map.insert(HostKeyCheckingKey, d->sshParameters.hostKeyCheckingMode);
map.insert(QLatin1String(PortsSpecKey), d->freePorts.toString());
map.insert(QLatin1String(VersionKey), d->version);
map.insert(PortsSpecKey, d->freePorts.toString());
map.insert(VersionKey, d->version);
map.insert(QLatin1String(DebugServerKey), d->debugServerPath.toSettings());
map.insert(QLatin1String(QmlRuntimeKey), d->qmlRunCommand.toSettings());
map.insert(DebugServerKey, d->debugServerPath.toSettings());
map.insert(QmlRuntimeKey, d->qmlRunCommand.toSettings());
map.insert(ExtraDataKey, d->extraData);
map.insert(ExtraDataKey, QVariant::fromValue(d->extraData));
return map;
}
@@ -608,12 +607,12 @@ void IDevice::setQmlRunCommand(const FilePath &path)
void IDevice::setExtraData(Id kind, const QVariant &data)
{
d->extraData.insert(kind.toString(), data);
d->extraData.insert(keyFromString(kind.toString()), data);
}
QVariant IDevice::extraData(Id kind) const
{
return d->extraData.value(kind.toString());
return d->extraData.value(keyFromString(kind.toString()));
}
int IDevice::version() const

34
src/plugins/projectexplorer/editorconfiguration.cpp
View File

@@ -27,17 +27,17 @@
#include <QTextCodec>
#include <QDebug>
static const QLatin1String kPrefix("EditorConfiguration.");
static const QLatin1String kUseGlobal("EditorConfiguration.UseGlobal");
static const QLatin1String kCodec("EditorConfiguration.Codec");
static const QLatin1String kCodeStylePrefix("EditorConfiguration.CodeStyle.");
static const QLatin1String kCodeStyleCount("EditorConfiguration.CodeStyle.Count");
using namespace TextEditor;
using namespace Utils;
namespace ProjectExplorer {
const Key kPrefix("EditorConfiguration.");
const Key kUseGlobal("EditorConfiguration.UseGlobal");
const Key kCodec("EditorConfiguration.Codec");
const Key kCodeStylePrefix("EditorConfiguration.CodeStyle.");
const Key kCodeStyleCount("EditorConfiguration.CodeStyle.Count");
struct EditorConfigurationPrivate
{
EditorConfigurationPrivate() :
@@ -159,15 +159,15 @@ QMap<Utils::Id, ICodeStylePreferences *> EditorConfiguration::codeStyles() const
return d->m_languageCodeStylePreferences;
}
static void toMapWithPrefix(QVariantMap *map, const QVariantMap &source)
static void toMapWithPrefix(Store *map, const Store &source)
{
for (auto it = source.constBegin(), end = source.constEnd(); it != end; ++it)
map->insert(kPrefix + it.key(), it.value());
}
QVariantMap EditorConfiguration::toMap() const
Store EditorConfiguration::toMap() const
{
QVariantMap map = {
Store map = {
{kUseGlobal, d->m_useGlobal},
{kCodec, d->m_textCodec->name()},
{kCodeStyleCount, d->m_languageCodeStylePreferences.count()}
@@ -177,11 +177,11 @@ QVariantMap EditorConfiguration::toMap() const
for (auto itCodeStyle = d->m_languageCodeStylePreferences.cbegin(),
end = d->m_languageCodeStylePreferences.cend();
itCodeStyle != end; ++itCodeStyle) {
const QVariantMap settingsIdMap = {
{"language", itCodeStyle.key().toSetting()},
{"value", itCodeStyle.value()->toMap()}
const Store settingsIdMap = {
{"language", QVariant::fromValue(itCodeStyle.key().toSetting())},
{"value", QVariant::fromValue(itCodeStyle.value()->toMap())}
};
map.insert(kCodeStylePrefix + QString::number(i), settingsIdMap);
map.insert(kCodeStylePrefix + Key::number(i), QVariant::fromValue(settingsIdMap));
i++;
}
@@ -204,19 +204,19 @@ void EditorConfiguration::fromMap(const Store &map)
const int codeStyleCount = map.value(kCodeStyleCount, 0).toInt();
for (int i = 0; i < codeStyleCount; ++i) {
QVariantMap settingsIdMap = map.value(kCodeStylePrefix + QString::number(i)).toMap();
Store settingsIdMap = map.value(kCodeStylePrefix + Key::number(i)).value<Store>();
if (settingsIdMap.isEmpty()) {
qWarning() << "No data for code style settings list" << i << "found!";
continue;
}
Utils::Id languageId = Utils::Id::fromSetting(settingsIdMap.value(QLatin1String("language")));
QVariantMap value = settingsIdMap.value(QLatin1String("value")).toMap();
Id languageId = Id::fromSetting(settingsIdMap.value("language"));
Store value = settingsIdMap.value("value").value<Store>();
ICodeStylePreferences *preferences = d->m_languageCodeStylePreferences.value(languageId);
if (preferences)
preferences->fromMap(value);
}
QVariantMap submap;
Store submap;
for (auto it = map.constBegin(), end = map.constEnd(); it != end; ++it) {
if (it.key().startsWith(kPrefix))
submap.insert(it.key().mid(kPrefix.size()), it.value());

4
src/plugins/projectexplorer/jsonwizard/jsonfieldpage.cpp
View File

@@ -525,7 +525,7 @@ QWidget *LineEditField::createWidget(const QString &displayName, JsonFieldPage *
w->setFixupExpando(m_fixupExpando);
if (!m_historyId.isEmpty())
w->setHistoryCompleter(m_historyId, m_restoreLastHistoryItem);
w->setHistoryCompleter(keyFromString(m_historyId), m_restoreLastHistoryItem);
w->setEchoMode(m_isPassword ? QLineEdit::Password : QLineEdit::Normal);
QObject::connect(w, &FancyLineEdit::textEdited, [this] { setHasUserChanges(); });
@@ -800,7 +800,7 @@ QWidget *PathChooserField::createWidget(const QString &displayName, JsonFieldPag
Q_UNUSED(page)
auto w = new PathChooser;
if (!m_historyId.isEmpty())
w->setHistoryCompleter(m_historyId);
w->setHistoryCompleter(keyFromString(m_historyId));
QObject::connect(w, &PathChooser::textChanged, [this, w] {
if (w->filePath() != m_path)
setHasUserChanges();

55
src/plugins/projectexplorer/kit.cpp
View File

@@ -123,41 +123,40 @@ Kit::Kit(Id id)
{
}
Kit::Kit(const QVariantMap &data) :
d(std::make_unique<Internal::KitPrivate>(Id(), this))
Kit::Kit(const Store &data)
: d(std::make_unique<Internal::KitPrivate>(Id(), this))
{
d->m_id = Id::fromSetting(data.value(QLatin1String(ID_KEY)));
d->m_id = Id::fromSetting(data.value(ID_KEY));
d->m_autodetected = data.value(QLatin1String(AUTODETECTED_KEY)).toBool();
d->m_autoDetectionSource = data.value(QLatin1String(AUTODETECTIONSOURCE_KEY)).toString();
d->m_autodetected = data.value(AUTODETECTED_KEY).toBool();
d->m_autoDetectionSource = data.value(AUTODETECTIONSOURCE_KEY).toString();
// if we don't have that setting assume that autodetected implies sdk
QVariant value = data.value(QLatin1String(SDK_PROVIDED_KEY));
QVariant value = data.value(SDK_PROVIDED_KEY);
if (value.isValid())
d->m_sdkProvided = value.toBool();
else
d->m_sdkProvided = d->m_autodetected;
d->m_unexpandedDisplayName.fromMap(data, DISPLAYNAME_KEY);
d->m_fileSystemFriendlyName = data.value(QLatin1String(FILESYSTEMFRIENDLYNAME_KEY)).toString();
d->m_iconPath = FilePath::fromString(data.value(QLatin1String(ICON_KEY),
d->m_iconPath.toString()).toString());
d->m_fileSystemFriendlyName = data.value(FILESYSTEMFRIENDLYNAME_KEY).toString();
d->m_iconPath = FilePath::fromString(data.value(ICON_KEY, d->m_iconPath.toString()).toString());
d->m_deviceTypeForIcon = Id::fromSetting(data.value(DEVICE_TYPE_FOR_ICON_KEY));
const auto it = data.constFind(IRRELEVANT_ASPECTS_KEY);
if (it != data.constEnd())
d->m_irrelevantAspects = transform<QSet<Id>>(it.value().toList(), &Id::fromSetting);
QVariantMap extra = data.value(QLatin1String(DATA_KEY)).toMap();
Store extra = data.value(DATA_KEY).value<Store>();
d->m_data.clear(); // remove default values
const QVariantMap::ConstIterator cend = extra.constEnd();
for (QVariantMap::ConstIterator it = extra.constBegin(); it != cend; ++it)
d->m_data.insert(Id::fromString(it.key()), it.value());
const Store::ConstIterator cend = extra.constEnd();
for (Store::ConstIterator it = extra.constBegin(); it != cend; ++it)
d->m_data.insert(Id::fromString(stringFromKey(it.key())), it.value());
const QStringList mutableInfoList = data.value(QLatin1String(MUTABLE_INFO_KEY)).toStringList();
const QStringList mutableInfoList = data.value(MUTABLE_INFO_KEY).toStringList();
for (const QString &mutableInfo : mutableInfoList)
d->m_mutable.insert(Id::fromString(mutableInfo));
const QStringList stickyInfoList = data.value(QLatin1String(STICKY_INFO_KEY)).toStringList();
const QStringList stickyInfoList = data.value(STICKY_INFO_KEY).toStringList();
for (const QString &stickyInfo : stickyInfoList)
d->m_sticky.insert(Id::fromString(stickyInfo));
}
@@ -484,42 +483,42 @@ bool Kit::isEqual(const Kit *other) const
&& d->m_mutable == other->d->m_mutable;
}
QVariantMap Kit::toMap() const
Store Kit::toMap() const
{
using IdVariantConstIt = QHash<Id, QVariant>::ConstIterator;
QVariantMap data;
Store data;
d->m_unexpandedDisplayName.toMap(data, DISPLAYNAME_KEY);
data.insert(QLatin1String(ID_KEY), QString::fromLatin1(d->m_id.name()));
data.insert(QLatin1String(AUTODETECTED_KEY), d->m_autodetected);
data.insert(ID_KEY, QString::fromLatin1(d->m_id.name()));
data.insert(AUTODETECTED_KEY, d->m_autodetected);
if (!d->m_fileSystemFriendlyName.isEmpty())
data.insert(QLatin1String(FILESYSTEMFRIENDLYNAME_KEY), d->m_fileSystemFriendlyName);
data.insert(QLatin1String(AUTODETECTIONSOURCE_KEY), d->m_autoDetectionSource);
data.insert(QLatin1String(SDK_PROVIDED_KEY), d->m_sdkProvided);
data.insert(QLatin1String(ICON_KEY), d->m_iconPath.toString());
data.insert(FILESYSTEMFRIENDLYNAME_KEY, d->m_fileSystemFriendlyName);
data.insert(AUTODETECTIONSOURCE_KEY, d->m_autoDetectionSource);
data.insert(SDK_PROVIDED_KEY, d->m_sdkProvided);
data.insert(ICON_KEY, d->m_iconPath.toString());
data.insert(DEVICE_TYPE_FOR_ICON_KEY, d->m_deviceTypeForIcon.toSetting());
QStringList mutableInfo;
for (const Id id : std::as_const(d->m_mutable))
mutableInfo << id.toString();
data.insert(QLatin1String(MUTABLE_INFO_KEY), mutableInfo);
data.insert(MUTABLE_INFO_KEY, mutableInfo);
QStringList stickyInfo;
for (const Id id : std::as_const(d->m_sticky))
stickyInfo << id.toString();
data.insert(QLatin1String(STICKY_INFO_KEY), stickyInfo);
data.insert(STICKY_INFO_KEY, stickyInfo);
if (d->m_irrelevantAspects) {
data.insert(IRRELEVANT_ASPECTS_KEY, transform<QVariantList>(d->m_irrelevantAspects.value(),
&Id::toSetting));
}
QVariantMap extra;
Store extra;
const IdVariantConstIt cend = d->m_data.constEnd();
for (IdVariantConstIt it = d->m_data.constBegin(); it != cend; ++it)
extra.insert(QString::fromLatin1(it.key().name().constData()), it.value());
data.insert(QLatin1String(DATA_KEY), extra);
extra.insert(keyFromString(QString::fromLatin1(it.key().name().constData())), it.value());
data.insert(DATA_KEY, QVariant::fromValue(extra));
return data;
}

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

@@ -40,8 +40,8 @@ public:
using Predicate = std::function<bool(const Kit *)>;
static Predicate defaultPredicate();
explicit Kit(Utils::Id id = Utils::Id());
explicit Kit(const QVariantMap &data);
explicit Kit(Utils::Id id = {});
explicit Kit(const Utils::Store &data);
~Kit();
// Do not trigger evaluations

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

@@ -53,7 +53,7 @@ public:
{
m_chooser = createSubWidget<PathChooser>();
m_chooser->setExpectedKind(PathChooser::ExistingDirectory);
m_chooser->setHistoryCompleter(QLatin1String("PE.SysRoot.History"));
m_chooser->setHistoryCompleter("PE.SysRoot.History");
m_chooser->setFilePath(SysRootKitAspect::sysRoot(k));
connect(m_chooser, &PathChooser::textChanged,
this, &SysRootKitAspectImpl::pathWasChanged);

24
src/plugins/projectexplorer/kitmanager.cpp
View File

@@ -439,20 +439,20 @@ void KitManager::saveKits()
if (!d->m_writer) // ignore save requests while we are not initialized.
return;
QVariantMap data;
data.insert(QLatin1String(KIT_FILE_VERSION_KEY), 1);
Store data;
data.insert(KIT_FILE_VERSION_KEY, 1);
int count = 0;
const QList<Kit *> kits = KitManager::kits();
for (Kit *k : kits) {
QVariantMap tmp = k->toMap();
Store tmp = k->toMap();
if (tmp.isEmpty())
continue;
data.insert(QString::fromLatin1(KIT_DATA_KEY) + QString::number(count), tmp);
data.insert(KIT_DATA_KEY + Key::number(count), QVariant::fromValue(tmp));
++count;
}
data.insert(QLatin1String(KIT_COUNT_KEY), count);
data.insert(QLatin1String(KIT_DEFAULT_KEY),
data.insert(KIT_COUNT_KEY, count);
data.insert(KIT_DEFAULT_KEY,
d->m_defaultKit ? QString::fromLatin1(d->m_defaultKit->id().name()) : QString());
data.insert(KIT_IRRELEVANT_ASPECTS_KEY,
transform<QVariantList>(d->m_irrelevantAspects, &Id::toSetting));
@@ -503,22 +503,22 @@ static KitList restoreKitsHelper(const FilePath &fileName)
qPrintable(fileName.toUserOutput()));
return result;
}
QVariantMap data = reader.restoreValues();
Store data = reader.restoreValues();
// Check version:
int version = data.value(QLatin1String(KIT_FILE_VERSION_KEY), 0).toInt();
int version = data.value(KIT_FILE_VERSION_KEY, 0).toInt();
if (version < 1) {
qWarning("Warning: Kit file version %d not supported, cannot restore kits!", version);
return result;
}
const int count = data.value(QLatin1String(KIT_COUNT_KEY), 0).toInt();
const int count = data.value(KIT_COUNT_KEY, 0).toInt();
for (int i = 0; i < count; ++i) {
const QString key = QString::fromLatin1(KIT_DATA_KEY) + QString::number(i);
const Key key = KIT_DATA_KEY + Key::number(i);
if (!data.contains(key))
break;
const QVariantMap stMap = data.value(key).toMap();
const Store stMap = data.value(key).value<Store>();
auto k = std::make_unique<Kit>(stMap);
if (k->id().isValid()) {
@@ -529,7 +529,7 @@ static KitList restoreKitsHelper(const FilePath &fileName)
i);
}
}
const Id id = Id::fromSetting(data.value(QLatin1String(KIT_DEFAULT_KEY)));
const Id id = Id::fromSetting(data.value(KIT_DEFAULT_KEY));
if (!id.isValid())
return result;

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

@@ -37,14 +37,14 @@ Kit *ProjectConfiguration::kit() const
return m_target->kit();
}
Utils::Id ProjectConfiguration::id() const
Id ProjectConfiguration::id() const
{
return m_id;
}
QString ProjectConfiguration::settingsIdKey()
Key ProjectConfiguration::settingsIdKey()
{
return QString(CONFIGURATION_ID_KEY);
return CONFIGURATION_ID_KEY;
}
void ProjectConfiguration::setDisplayName(const QString &name)
@@ -75,7 +75,7 @@ QString ProjectConfiguration::toolTip() const
void ProjectConfiguration::toMap(Store &map) const
{
QTC_CHECK(m_id.isValid());
map.insert(QLatin1String(CONFIGURATION_ID_KEY), m_id.toSetting());
map.insert(CONFIGURATION_ID_KEY, m_id.toSetting());
m_displayName.toMap(map, DISPLAY_NAME_KEY);
AspectContainer::toMap(map);
}
@@ -87,18 +87,18 @@ Target *ProjectConfiguration::target() const
void ProjectConfiguration::fromMap(const Store &map)
{
Utils::Id id = Utils::Id::fromSetting(map.value(QLatin1String(CONFIGURATION_ID_KEY)));
Id id = Id::fromSetting(map.value(CONFIGURATION_ID_KEY));
// Note: This is only "startsWith", not ==, as RunConfigurations currently still
// mangle in their build keys.
QTC_ASSERT(id.toString().startsWith(m_id.toString()), reportError(); return);
QTC_ASSERT(id.name().startsWith(m_id.name()), reportError(); return);
m_displayName.fromMap(map, DISPLAY_NAME_KEY);
AspectContainer::fromMap(map);
}
Id ProjectExplorer::idFromMap(const QVariantMap &map)
Id ProjectExplorer::idFromMap(const Store &map)
{
return Id::fromSetting(map.value(QLatin1String(CONFIGURATION_ID_KEY)));
return Id::fromSetting(map.value(CONFIGURATION_ID_KEY));
}
QString ProjectConfiguration::expandedDisplayName() const

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

@@ -53,7 +53,7 @@ public:
Project *project() const;
Kit *kit() const;
static QString settingsIdKey();
static Utils::Key settingsIdKey();
signals:
void displayNameChanged();

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

@@ -496,7 +496,7 @@ void FlatModel::saveExpandData()
{
// TODO if there are multiple ProjectTreeWidgets, the last one saves the data
QList<QVariant> data = Utils::transform<QList>(m_toExpand, &ExpandData::toSettings);
SessionManager::setValue(QLatin1String("ProjectTree.ExpandData"), data);
SessionManager::setValue("ProjectTree.ExpandData", data);
}
void FlatModel::addFolderNode(WrapperNode *parent, FolderNode *folderNode, QSet<Node *> *seen)

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

@@ -638,7 +638,7 @@ void ProjectTreeWidgetFactory::saveSettings(QtcSettings *settings, int position,
{
auto ptw = qobject_cast<ProjectTreeWidget *>(widget);
Q_ASSERT(ptw);
const QString baseKey = kBaseKey + QString::number(position);
const Key baseKey = kBaseKey + Key::number(position);
settings->setValueWithDefault(baseKey + kProjectFilterKey,
ptw->projectFilter(),
kProjectFilterDefault);

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

@@ -89,14 +89,14 @@ void GlobalOrProjectAspect::fromMap(const Store &map)
{
if (m_projectSettings)
m_projectSettings->fromMap(map);
m_useGlobalSettings = map.value(id().toString() + ".UseGlobalSettings", true).toBool();
m_useGlobalSettings = map.value(keyFromString(id().toString() + ".UseGlobalSettings"), true).toBool();
}
void GlobalOrProjectAspect::toMap(Store &map) const
{
if (m_projectSettings)
m_projectSettings->toMap(map);
map.insert(id().toString() + ".UseGlobalSettings", m_useGlobalSettings);
map.insert(keyFromString(id().toString() + ".UseGlobalSettings"), m_useGlobalSettings);
}
void GlobalOrProjectAspect::toActiveMap(Store &data) const

6
src/plugins/projectexplorer/runconfigurationaspects.cpp
View File

@@ -564,7 +564,7 @@ void ExecutableAspect::setDeviceSelector(Target *target, ExecutionDeviceSelector
\sa Utils::PathChooser::setHistoryCompleter()
*/
void ExecutableAspect::setHistoryCompleter(const QString &historyCompleterKey)
void ExecutableAspect::setHistoryCompleter(const Key &historyCompleterKey)
{
m_executable.setHistoryCompleter(historyCompleterKey);
if (m_alternativeExecutable)
@@ -609,7 +609,7 @@ void ExecutableAspect::setReadOnly(bool readOnly)
\sa Utils::StringAspect::makeCheckable()
*/
void ExecutableAspect::makeOverridable(const QString &overridingKey, const QString &useOverridableKey)
void ExecutableAspect::makeOverridable(const Key &overridingKey, const Key &useOverridableKey)
{
QTC_ASSERT(!m_alternativeExecutable, return);
m_alternativeExecutable = new FilePathAspect;
@@ -684,7 +684,7 @@ void ExecutableAspect::setExecutable(const FilePath &executable)
/*!
Sets the settings key to \a key.
*/
void ExecutableAspect::setSettingsKey(const QString &key)
void ExecutableAspect::setSettingsKey(const Key &key)
{
BaseAspect::setSettingsKey(key);
m_executable.setSettingsKey(key);

6
src/plugins/projectexplorer/runconfigurationaspects.h
View File

@@ -167,12 +167,12 @@ public:
void setExecutable(const Utils::FilePath &executable);
void setDeviceSelector(Target *target, ExecutionDeviceSelector selector);
void setSettingsKey(const QString &key);
void makeOverridable(const QString &overridingKey, const QString &useOverridableKey);
void setSettingsKey(const Utils::Key &key);
void makeOverridable(const Utils::Key &overridingKey, const Utils::Key &useOverridableKey);
void addToLayout(Layouting::LayoutItem &parent) override;
void setLabelText(const QString &labelText);
void setPlaceHolderText(const QString &placeHolderText);
void setHistoryCompleter(const QString &historyCompleterKey);
void setHistoryCompleter(const Utils::Key &historyCompleterKey);
void setExpectedKind(const Utils::PathChooser::Kind expectedKind);
void setEnvironment(const Utils::Environment &env);
void setReadOnly(bool readOnly);

76
src/plugins/projectexplorer/target.cpp
View File

@@ -91,7 +91,7 @@ public:
DeployConfiguration *m_activeDeployConfiguration = nullptr;
QList<RunConfiguration *> m_runConfigurations;
RunConfiguration* m_activeRunConfiguration = nullptr;
QVariantMap m_pluginSettings;
Store m_pluginSettings;
Kit *const m_kit;
MacroExpander m_macroExpander;
@@ -321,14 +321,14 @@ QString Target::toolTip() const
return d->m_kit->toHtml();
}
QString Target::displayNameKey()
Key Target::displayNameKey()
{
return QString("ProjectExplorer.ProjectConfiguration.DisplayName");
return "ProjectExplorer.ProjectConfiguration.DisplayName";
}
QString Target::deviceTypeKey()
Key Target::deviceTypeKey()
{
return QString("DeviceType");
return "DeviceType";
}
void Target::addBuildConfiguration(BuildConfiguration *bc)
@@ -581,12 +581,12 @@ QString Target::overlayIconToolTip()
return current.isNull() ? QString() : formatDeviceInfo(current->deviceInformation());
}
QVariantMap Target::toMap() const
Store Target::toMap() const
{
if (!d->m_kit) // Kit was deleted, target is only around to be copied.
return {};
QVariantMap map;
Store map;
map.insert(displayNameKey(), displayName());
map.insert(deviceTypeKey(), DeviceTypeKitAspect::deviceTypeId(kit()).toSetting());
@@ -595,39 +595,39 @@ QVariantMap Target::toMap() const
// This is only read by older versions of Creator, but even there not actively used.
const char CONFIGURATION_ID_KEY[] = "ProjectExplorer.ProjectConfiguration.Id";
const char DEFAULT_DISPLAY_NAME_KEY[] = "ProjectExplorer.ProjectConfiguration.DefaultDisplayName";
map.insert(QLatin1String(CONFIGURATION_ID_KEY), id().toSetting());
map.insert(QLatin1String(DEFAULT_DISPLAY_NAME_KEY), displayName());
map.insert(CONFIGURATION_ID_KEY, id().toSetting());
map.insert(DEFAULT_DISPLAY_NAME_KEY, displayName());
}
const QList<BuildConfiguration *> bcs = buildConfigurations();
map.insert(QLatin1String(ACTIVE_BC_KEY), bcs.indexOf(d->m_activeBuildConfiguration));
map.insert(QLatin1String(BC_COUNT_KEY), bcs.size());
map.insert(ACTIVE_BC_KEY, bcs.indexOf(d->m_activeBuildConfiguration));
map.insert(BC_COUNT_KEY, bcs.size());
for (int i = 0; i < bcs.size(); ++i) {
QVariantMap data;
Store data;
bcs.at(i)->toMap(data);
map.insert(QString::fromLatin1(BC_KEY_PREFIX) + QString::number(i), data);
map.insert(BC_KEY_PREFIX + Key::number(i), QVariant::fromValue(data));
}
const QList<DeployConfiguration *> dcs = deployConfigurations();
map.insert(QLatin1String(ACTIVE_DC_KEY), dcs.indexOf(d->m_activeDeployConfiguration));
map.insert(QLatin1String(DC_COUNT_KEY), dcs.size());
map.insert(ACTIVE_DC_KEY, dcs.indexOf(d->m_activeDeployConfiguration));
map.insert(DC_COUNT_KEY, dcs.size());
for (int i = 0; i < dcs.size(); ++i) {
QVariantMap data;
Store data;
dcs.at(i)->toMap(data);
map.insert(QString::fromLatin1(DC_KEY_PREFIX) + QString::number(i), data);
map.insert(DC_KEY_PREFIX + Key::number(i), QVariant::fromValue(data));
}
const QList<RunConfiguration *> rcs = runConfigurations();
map.insert(QLatin1String(ACTIVE_RC_KEY), rcs.indexOf(d->m_activeRunConfiguration));
map.insert(QLatin1String(RC_COUNT_KEY), rcs.size());
map.insert(ACTIVE_RC_KEY, rcs.indexOf(d->m_activeRunConfiguration));
map.insert(RC_COUNT_KEY, rcs.size());
for (int i = 0; i < rcs.size(); ++i) {
QVariantMap data;
Store data;
rcs.at(i)->toMap(data);
map.insert(QString::fromLatin1(RC_KEY_PREFIX) + QString::number(i), data);
map.insert(RC_KEY_PREFIX + Key::number(i), QVariant::fromValue(data));
}
if (!d->m_pluginSettings.isEmpty())
map.insert(QLatin1String(PLUGIN_SETTINGS_KEY), d->m_pluginSettings);
map.insert(PLUGIN_SETTINGS_KEY, d->m_pluginSettings);
return map;
}
@@ -810,12 +810,12 @@ void Target::updateDefaultRunConfigurations()
emit runConfigurationsUpdated();
}
QVariant Target::namedSettings(const QString &name) const
QVariant Target::namedSettings(const Key &name) const
{
return d->m_pluginSettings.value(name);
}
void Target::setNamedSettings(const QString &name, const QVariant &value)
void Target::setNamedSettings(const Key &name, const QVariant &value)
{
if (value.isNull())
d->m_pluginSettings.remove(name);
@@ -890,20 +890,20 @@ bool Target::fromMap(const Store &map)
QTC_ASSERT(d->m_kit == KitManager::kit(id()), return false);
bool ok;
int bcCount = map.value(QLatin1String(BC_COUNT_KEY), 0).toInt(&ok);
int bcCount = map.value(BC_COUNT_KEY, 0).toInt(&ok);
if (!ok || bcCount < 0)
bcCount = 0;
int activeConfiguration = map.value(QLatin1String(ACTIVE_BC_KEY), 0).toInt(&ok);
int activeConfiguration = map.value(ACTIVE_BC_KEY, 0).toInt(&ok);
if (!ok || activeConfiguration < 0)
activeConfiguration = 0;
if (0 > activeConfiguration || bcCount < activeConfiguration)
activeConfiguration = 0;
for (int i = 0; i < bcCount; ++i) {
const QString key = QString::fromLatin1(BC_KEY_PREFIX) + QString::number(i);
const Key key = BC_KEY_PREFIX + Key::number(i);
if (!map.contains(key))
return false;
const QVariantMap valueMap = map.value(key).toMap();
const Store valueMap = map.value(key).toMap();
BuildConfiguration *bc = BuildConfigurationFactory::restore(this, valueMap);
if (!bc) {
qWarning("No factory found to restore build configuration!");
@@ -917,20 +917,20 @@ bool Target::fromMap(const Store &map)
if (buildConfigurations().isEmpty() && BuildConfigurationFactory::find(this))
return false;
int dcCount = map.value(QLatin1String(DC_COUNT_KEY), 0).toInt(&ok);
int dcCount = map.value(DC_COUNT_KEY, 0).toInt(&ok);
if (!ok || dcCount < 0)
dcCount = 0;
activeConfiguration = map.value(QLatin1String(ACTIVE_DC_KEY), 0).toInt(&ok);
activeConfiguration = map.value(ACTIVE_DC_KEY, 0).toInt(&ok);
if (!ok || activeConfiguration < 0)
activeConfiguration = 0;
if (0 > activeConfiguration || dcCount < activeConfiguration)
activeConfiguration = 0;
for (int i = 0; i < dcCount; ++i) {
const QString key = QString::fromLatin1(DC_KEY_PREFIX) + QString::number(i);
const Key key = DC_KEY_PREFIX + Key::number(i);
if (!map.contains(key))
return false;
QVariantMap valueMap = map.value(key).toMap();
Store valueMap = map.value(key).value<Store>();
DeployConfiguration *dc = DeployConfigurationFactory::restore(this, valueMap);
if (!dc) {
Utils::Id id = idFromMap(valueMap);
@@ -944,22 +944,22 @@ bool Target::fromMap(const Store &map)
setActiveDeployConfiguration(dc);
}
int rcCount = map.value(QLatin1String(RC_COUNT_KEY), 0).toInt(&ok);
int rcCount = map.value(RC_COUNT_KEY, 0).toInt(&ok);
if (!ok || rcCount < 0)
rcCount = 0;
activeConfiguration = map.value(QLatin1String(ACTIVE_RC_KEY), 0).toInt(&ok);
activeConfiguration = map.value(ACTIVE_RC_KEY, 0).toInt(&ok);
if (!ok || activeConfiguration < 0)
activeConfiguration = 0;
if (0 > activeConfiguration || rcCount < activeConfiguration)
activeConfiguration = 0;
for (int i = 0; i < rcCount; ++i) {
const QString key = QString::fromLatin1(RC_KEY_PREFIX) + QString::number(i);
const Key key = RC_KEY_PREFIX + Key::number(i);
if (!map.contains(key))
return false;
// Ignore missing RCs: We will just populate them using the default ones.
QVariantMap valueMap = map.value(key).toMap();
Store valueMap = map.value(key).value<Store>();
RunConfiguration *rc = RunConfigurationFactory::restore(this, valueMap);
if (!rc)
continue;
@@ -972,8 +972,8 @@ bool Target::fromMap(const Store &map)
setActiveRunConfiguration(rc);
}
if (map.contains(QLatin1String(PLUGIN_SETTINGS_KEY)))
d->m_pluginSettings = map.value(QLatin1String(PLUGIN_SETTINGS_KEY)).toMap();
if (map.contains(PLUGIN_SETTINGS_KEY))
d->m_pluginSettings = map.value(PLUGIN_SETTINGS_KEY).toMap();
return true;
}

8
src/plugins/projectexplorer/target.h
View File

@@ -57,8 +57,8 @@ public:
QString displayName() const;
QString toolTip() const;
static QString displayNameKey();
static QString deviceTypeKey();
static Utils::Key displayNameKey();
static Utils::Key deviceTypeKey();
// Build configuration
void addBuildConfiguration(BuildConfiguration *bc);
@@ -94,8 +94,8 @@ public:
void updateDefaultDeployConfigurations();
void updateDefaultRunConfigurations();
QVariant namedSettings(const QString &name) const;
void setNamedSettings(const QString &name, const QVariant &value);
QVariant namedSettings(const Utils::Key &name) const;
void setNamedSettings(const Utils::Key &name, const QVariant &value);
QVariant additionalData(Utils::Id id) const;

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

@@ -138,7 +138,7 @@ void TargetSetupWidget::addBuildInfo(const BuildInfo &info, bool isImport)
store.pathChooser = new PathChooser();
store.pathChooser->setExpectedKind(PathChooser::Directory);
store.pathChooser->setFilePath(info.buildDirectory);
store.pathChooser->setHistoryCompleter(QLatin1String("TargetSetup.BuildDir.History"));
store.pathChooser->setHistoryCompleter("TargetSetup.BuildDir.History");
store.pathChooser->setReadOnly(isImport);
m_newBuildsLayout->addWidget(store.pathChooser, pos * 2, 1);

8
src/plugins/projectexplorer/taskwindow.cpp
View File

@@ -343,19 +343,19 @@ void TaskWindow::saveSettings()
{
const QStringList categories = Utils::toList(
Utils::transform(d->m_filter->filteredCategories(), &Id::toString));
SessionManager::setValue(QLatin1String(SESSION_FILTER_CATEGORIES), categories);
SessionManager::setValue(QLatin1String(SESSION_FILTER_WARNINGS), d->m_filter->filterIncludesWarnings());
SessionManager::setValue(SESSION_FILTER_CATEGORIES, categories);
SessionManager::setValue(SESSION_FILTER_WARNINGS, d->m_filter->filterIncludesWarnings());
}
void TaskWindow::loadSettings()
{
QVariant value = SessionManager::value(QLatin1String(SESSION_FILTER_CATEGORIES));
QVariant value = SessionManager::value(SESSION_FILTER_CATEGORIES);
if (value.isValid()) {
const QSet<Id> categories = Utils::toSet(
Utils::transform(value.toStringList(), &Id::fromString));
d->m_filter->setFilteredCategories(categories);
}
value = SessionManager::value(QLatin1String(SESSION_FILTER_WARNINGS));
value = SessionManager::value(SESSION_FILTER_WARNINGS);
if (value.isValid()) {
bool includeWarnings = value.toBool();
d->m_filter->setFilterIncludesWarnings(includeWarnings);

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

@@ -50,14 +50,14 @@ public:
m_headerPathsCache(new ToolChain::HeaderPathsCache::element_type())
{
QTC_ASSERT(m_typeId.isValid(), return);
QTC_ASSERT(!m_typeId.toString().contains(QLatin1Char(':')), return);
QTC_ASSERT(!m_typeId.name().contains(':'), return);
}
QByteArray m_id;
FilePath m_compilerCommand;
QString m_compilerCommandKey;
Key m_compilerCommandKey;
Abi m_targetAbi;
QString m_targetAbiKey;
Key m_targetAbiKey;
QSet<Id> m_supportedLanguages;
mutable QString m_displayName;
QString m_typeDisplayName;
@@ -223,7 +223,7 @@ ToolChain *ToolChain::clone() const
if (f->supportedToolChainType() == d->m_typeId) {
ToolChain *tc = f->create();
QTC_ASSERT(tc, return nullptr);
QVariantMap data;
Store data;
toMap(data);
tc->fromMap(data);
// New ID for the clone. It's different.
@@ -246,10 +246,10 @@ void ToolChain::toMap(Store &result) const
AspectContainer::toMap(result);
QString idToSave = d->m_typeId.toString() + QLatin1Char(':') + QString::fromUtf8(id());
result.insert(QLatin1String(ID_KEY), idToSave);
result.insert(QLatin1String(DISPLAY_NAME_KEY), displayName());
result.insert(QLatin1String(AUTODETECT_KEY), isAutoDetected());
result.insert(QLatin1String(DETECTION_SOURCE_KEY), d->m_detectionSource);
result.insert(ID_KEY, idToSave);
result.insert(DISPLAY_NAME_KEY, displayName());
result.insert(AUTODETECT_KEY, isAutoDetected());
result.insert(DETECTION_SOURCE_KEY, d->m_detectionSource);
result.insert(CODE_MODEL_TRIPLE_KEY, d->m_explicitCodeModelTargetTriple);
// <Compatibility with QtC 4.2>
int oldLanguageId = -1;
@@ -260,7 +260,7 @@ void ToolChain::toMap(Store &result) const
if (oldLanguageId >= 0)
result.insert(LANGUAGE_KEY_V1, oldLanguageId);
// </Compatibility>
result.insert(QLatin1String(LANGUAGE_KEY_V2), language().toSetting());
result.insert(LANGUAGE_KEY_V2, language().toSetting());
if (!d->m_targetAbiKey.isEmpty())
result.insert(d->m_targetAbiKey, d->m_targetAbi.toString());
if (!d->m_compilerCommandKey.isEmpty())
@@ -553,7 +553,7 @@ void ToolChain::setExplicitCodeModelTargetTriple(const QString &triple)
*/
/*!
\fn bool ProjectExplorer::ToolChainFactory::canRestore(const QVariantMap &data)
\fn bool ProjectExplorer::ToolChainFactory::canRestore(const Store &data)
Used by the tool chain manager to restore user-generated tool chains.
*/
@@ -594,7 +594,7 @@ ToolChain *ToolChainFactory::create() const
return m_toolchainConstructor ? m_toolchainConstructor() : nullptr;
}
ToolChain *ToolChainFactory::restore(const QVariantMap &data)
ToolChain *ToolChainFactory::restore(const Store &data)
{
if (!m_toolchainConstructor)
return nullptr;
@@ -610,7 +610,7 @@ ToolChain *ToolChainFactory::restore(const QVariantMap &data)
return nullptr;
}
static QPair<QString, QString> rawIdData(const QVariantMap &data)
static QPair<QString, QString> rawIdData(const Store &data)
{
const QString raw = data.value(QLatin1String(ID_KEY)).toString();
const int pos = raw.indexOf(QLatin1Char(':'));
@@ -618,17 +618,17 @@ static QPair<QString, QString> rawIdData(const QVariantMap &data)
return {raw.mid(0, pos), raw.mid(pos + 1)};
}
QByteArray ToolChainFactory::idFromMap(const QVariantMap &data)
QByteArray ToolChainFactory::idFromMap(const Store &data)
{
return rawIdData(data).second.toUtf8();
}
Id ToolChainFactory::typeIdFromMap(const QVariantMap &data)
Id ToolChainFactory::typeIdFromMap(const Store &data)
{
return Id::fromString(rawIdData(data).first);
}
void ToolChainFactory::autoDetectionToMap(QVariantMap &data, bool detected)
void ToolChainFactory::autoDetectionToMap(Store &data, bool detected)
{
data.insert(QLatin1String(AUTODETECT_KEY), detected);
}
@@ -704,7 +704,7 @@ static QString badToolchainFilePathKey() { return {"FilePath"}; }
static QString badToolchainSymlinkTargetKey() { return {"TargetFilePath"}; }
static QString badToolchainTimestampKey() { return {"Timestamp"}; }
QVariantMap BadToolchain::toMap() const
Store BadToolchain::toMap() const
{
return {{badToolchainFilePathKey(), filePath.toSettings()},
{badToolchainSymlinkTargetKey(), symlinkTarget.toSettings()},

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

@@ -15,13 +15,9 @@
#include <utils/aspects.h>
#include <utils/cpplanguage_details.h>
#include <utils/environment.h>
#include <utils/fileutils.h>
#include <utils/id.h>
#include <utils/store.h>
#include <QDateTime>
#include <QObject>
#include <QStringList>
#include <QVariantMap>
#include <functional>
#include <memory>

144
src/plugins/projectexplorer/userfileaccessor.cpp
View File

@@ -48,7 +48,7 @@ class UserFileVersion14Upgrader : public VersionUpgrader
{
public:
UserFileVersion14Upgrader() : VersionUpgrader(14, "3.0-pre1") { }
QVariantMap upgrade(const QVariantMap &map) final;
Store upgrade(const Store &map) final;
};
// Version 15 Use settingsaccessor based class for user file reading/writing
@@ -56,7 +56,7 @@ class UserFileVersion15Upgrader : public VersionUpgrader
{
public:
UserFileVersion15Upgrader() : VersionUpgrader(15, "3.2-pre1") { }
QVariantMap upgrade(const QVariantMap &map) final;
Store upgrade(const Store &map) final;
};
// Version 16 Changed android deployment
@@ -64,15 +64,15 @@ class UserFileVersion16Upgrader : public VersionUpgrader
{
public:
UserFileVersion16Upgrader() : VersionUpgrader(16, "3.3-pre1") { }
QVariantMap upgrade(const QVariantMap &data) final;
Store upgrade(const Store &data) final;
private:
class OldStepMaps
{
public:
QString defaultDisplayName;
QString displayName;
QVariantMap androidPackageInstall;
QVariantMap androidDeployQt;
Store androidPackageInstall;
Store androidDeployQt;
bool isEmpty()
{
return androidPackageInstall.isEmpty() || androidDeployQt.isEmpty();
@@ -80,10 +80,10 @@ private:
};
QVariantMap removeAndroidPackageStep(QVariantMap deployMap);
OldStepMaps extractStepMaps(const QVariantMap &deployMap);
Store removeAndroidPackageStep(Store deployMap);
OldStepMaps extractStepMaps(const Store &deployMap);
enum NamePolicy { KeepName, RenameBuildConfiguration };
QVariantMap insertSteps(QVariantMap buildConfigurationMap,
Store insertSteps(Store buildConfigurationMap,
const OldStepMaps &oldStepMap,
NamePolicy policy);
};
@@ -93,7 +93,7 @@ class UserFileVersion17Upgrader : public VersionUpgrader
{
public:
UserFileVersion17Upgrader() : VersionUpgrader(17, "3.3-pre2") { }
QVariantMap upgrade(const QVariantMap &map) final;
Store upgrade(const Store &map) final;
QVariant process(const QVariant &entry);
@@ -108,7 +108,7 @@ class UserFileVersion18Upgrader : public VersionUpgrader
{
public:
UserFileVersion18Upgrader() : VersionUpgrader(18, "4.8-pre1") { }
QVariantMap upgrade(const QVariantMap &map) final;
Store upgrade(const Store &map) final;
static QVariant process(const QVariant &entry);
};
@@ -119,7 +119,7 @@ class UserFileVersion19Upgrader : public VersionUpgrader
{
public:
UserFileVersion19Upgrader() : VersionUpgrader(19, "4.8-pre2") { }
QVariantMap upgrade(const QVariantMap &map) final;
Store upgrade(const Store &map) final;
static QVariant process(const QVariant &entry, const QStringList &path);
};
@@ -131,7 +131,7 @@ class UserFileVersion20Upgrader : public VersionUpgrader
{
public:
UserFileVersion20Upgrader() : VersionUpgrader(20, "4.9-pre1") { }
QVariantMap upgrade(const QVariantMap &map) final;
Store upgrade(const Store &map) final;
static QVariant process(const QVariant &entry);
};
@@ -143,7 +143,7 @@ class UserFileVersion21Upgrader : public VersionUpgrader
{
public:
UserFileVersion21Upgrader() : VersionUpgrader(21, "4.10-pre1") { }
QVariantMap upgrade(const QVariantMap &map) final;
Store upgrade(const Store &map) final;
static QVariant process(const QVariant &entry);
};
@@ -401,17 +401,17 @@ FilePath UserFileAccessor::sharedFile() const
.stringAppended(generateSuffix(qtcExt.isEmpty() ? ".shared" : qtcExt));
}
QVariantMap UserFileAccessor::postprocessMerge(const QVariantMap &main,
const QVariantMap &secondary,
const QVariantMap &result) const
Store UserFileAccessor::postprocessMerge(const Store &main,
const Store &secondary,
const Store &result) const
{
project()->setProperty(SHARED_SETTINGS, secondary);
return MergingSettingsAccessor::postprocessMerge(main, secondary, result);
}
QVariantMap UserFileAccessor::preprocessReadSettings(const QVariantMap &data) const
Store UserFileAccessor::preprocessReadSettings(const Store &data) const
{
QVariantMap tmp = MergingSettingsAccessor::preprocessReadSettings(data);
Store tmp = MergingSettingsAccessor::preprocessReadSettings(data);
// Move from old Version field to new one:
// This cannot be done in a normal upgrader since the version information is needed
@@ -426,11 +426,11 @@ QVariantMap UserFileAccessor::preprocessReadSettings(const QVariantMap &data) co
return tmp;
}
QVariantMap UserFileAccessor::prepareToWriteSettings(const QVariantMap &data) const
Store UserFileAccessor::prepareToWriteSettings(const Store &data) const
{
const QVariantMap tmp = MergingSettingsAccessor::prepareToWriteSettings(data);
const QVariantMap shared = retrieveSharedSettings().toMap();
QVariantMap result;
const Store tmp = MergingSettingsAccessor::prepareToWriteSettings(data);
const Store shared = retrieveSharedSettings().toMap();
Store result;
if (!shared.isEmpty()) {
QStringList stickyKeys;
SettingsMergeFunction merge = userStickyTrackerFunction(stickyKeys);
@@ -449,9 +449,9 @@ QVariantMap UserFileAccessor::prepareToWriteSettings(const QVariantMap &data) co
// UserFileVersion14Upgrader:
// --------------------------------------------------------------------
QVariantMap UserFileVersion14Upgrader::upgrade(const QVariantMap &map)
Store UserFileVersion14Upgrader::upgrade(const Store &map)
{
QVariantMap result;
Store result;
for (auto it = map.cbegin(), end = map.cend(); it != end; ++it) {
if (it.value().typeId() == QVariant::Map)
result.insert(it.key(), upgrade(it.value().toMap()));
@@ -471,30 +471,30 @@ QVariantMap UserFileVersion14Upgrader::upgrade(const QVariantMap &map)
// UserFileVersion15Upgrader:
// --------------------------------------------------------------------
QVariantMap UserFileVersion15Upgrader::upgrade(const QVariantMap &map)
Store UserFileVersion15Upgrader::upgrade(const Store &map)
{
const QList<Change> changes{{QLatin1String("ProjectExplorer.Project.Updater.EnvironmentId"),
QLatin1String("EnvironmentId")},
{QLatin1String("ProjectExplorer.Project.UserStickyKeys"),
QLatin1String("UserStickyKeys")}};
return renameKeys(changes, QVariantMap(map));
return renameKeys(changes, Store(map));
}
// --------------------------------------------------------------------
// UserFileVersion16Upgrader:
// --------------------------------------------------------------------
UserFileVersion16Upgrader::OldStepMaps UserFileVersion16Upgrader::extractStepMaps(const QVariantMap &deployMap)
UserFileVersion16Upgrader::OldStepMaps UserFileVersion16Upgrader::extractStepMaps(const Store &deployMap)
{
OldStepMaps result;
result.defaultDisplayName = deployMap.value("ProjectExplorer.ProjectConfiguration.DefaultDisplayName").toString();
result.displayName = deployMap.value("ProjectExplorer.ProjectConfiguration.DisplayName").toString();
const QString stepListKey = "ProjectExplorer.BuildConfiguration.BuildStepList.0";
QVariantMap stepListMap = deployMap.value(stepListKey).toMap();
Store stepListMap = deployMap.value(stepListKey).toMap();
int stepCount = stepListMap.value("ProjectExplorer.BuildStepList.StepsCount", 0).toInt();
QString stepKey = "ProjectExplorer.BuildStepList.Step.";
for (int i = 0; i < stepCount; ++i) {
QVariantMap stepMap = stepListMap.value(stepKey + QString::number(i)).toMap();
Store stepMap = stepListMap.value(stepKey + QString::number(i)).toMap();
const QString id = stepMap.value("ProjectExplorer.ProjectConfiguration.Id").toString();
if (id == "Qt4ProjectManager.AndroidDeployQtStep")
result.androidDeployQt = stepMap;
@@ -507,16 +507,16 @@ UserFileVersion16Upgrader::OldStepMaps UserFileVersion16Upgrader::extractStepMap
return result;
}
QVariantMap UserFileVersion16Upgrader::removeAndroidPackageStep(QVariantMap deployMap)
Store UserFileVersion16Upgrader::removeAndroidPackageStep(Store deployMap)
{
const QString stepListKey = "ProjectExplorer.BuildConfiguration.BuildStepList.0";
QVariantMap stepListMap = deployMap.value(stepListKey).toMap();
Store stepListMap = deployMap.value(stepListKey).toMap();
const QString stepCountKey = "ProjectExplorer.BuildStepList.StepsCount";
int stepCount = stepListMap.value(stepCountKey, 0).toInt();
QString stepKey = "ProjectExplorer.BuildStepList.Step.";
int targetPosition = 0;
for (int sourcePosition = 0; sourcePosition < stepCount; ++sourcePosition) {
QVariantMap stepMap = stepListMap.value(stepKey + QString::number(sourcePosition)).toMap();
Store stepMap = stepListMap.value(stepKey + QString::number(sourcePosition)).toMap();
if (stepMap.value("ProjectExplorer.ProjectConfiguration.Id").toString()
!= "Qt4ProjectManager.AndroidPackageInstallationStep") {
stepListMap.insert(stepKey + QString::number(targetPosition), stepMap);
@@ -533,7 +533,7 @@ QVariantMap UserFileVersion16Upgrader::removeAndroidPackageStep(QVariantMap depl
return deployMap;
}
QVariantMap UserFileVersion16Upgrader::insertSteps(QVariantMap buildConfigurationMap,
Store UserFileVersion16Upgrader::insertSteps(Store buildConfigurationMap,
const OldStepMaps &oldStepMap,
NamePolicy policy)
{
@@ -543,7 +543,7 @@ QVariantMap UserFileVersion16Upgrader::insertSteps(QVariantMap buildConfiguratio
const QString bslKey = "ProjectExplorer.BuildConfiguration.BuildStepList.";
const QString bslTypeKey = "ProjectExplorer.ProjectConfiguration.Id";
for (int bslNumber = 0; bslNumber < stepListCount; ++bslNumber) {
QVariantMap buildStepListMap = buildConfigurationMap.value(bslKey + QString::number(bslNumber)).toMap();
Store buildStepListMap = buildConfigurationMap.value(bslKey + QString::number(bslNumber)).toMap();
if (buildStepListMap.value(bslTypeKey) != "ProjectExplorer.BuildSteps.Build")
continue;
@@ -552,8 +552,8 @@ QVariantMap UserFileVersion16Upgrader::insertSteps(QVariantMap buildConfiguratio
int stepCount = buildStepListMap.value(bslStepCountKey).toInt();
buildStepListMap.insert(bslStepCountKey, stepCount + 2);
QVariantMap androidPackageInstallStep;
QVariantMap androidBuildApkStep;
Store androidPackageInstallStep;
Store androidBuildApkStep;
// common settings of all buildsteps
const QString enabledKey = "ProjectExplorer.BuildStep.Enabled";
@@ -628,17 +628,17 @@ QVariantMap UserFileVersion16Upgrader::insertSteps(QVariantMap buildConfiguratio
return buildConfigurationMap;
}
QVariantMap UserFileVersion16Upgrader::upgrade(const QVariantMap &data)
Store UserFileVersion16Upgrader::upgrade(const Store &data)
{
int targetCount = data.value("ProjectExplorer.Project.TargetCount", 0).toInt();
if (!targetCount)
return data;
QVariantMap result = data;
Store result = data;
for (int i = 0; i < targetCount; ++i) {
QString targetKey = QLatin1String("ProjectExplorer.Project.Target.") + QString::number(i);
QVariantMap targetMap = data.value(targetKey).toMap();
Store targetMap = data.value(targetKey).toMap();
const QString dcCountKey = "ProjectExplorer.Target.DeployConfigurationCount";
int deployconfigurationCount = targetMap.value(dcCountKey).toInt();
@@ -646,11 +646,11 @@ QVariantMap UserFileVersion16Upgrader::upgrade(const QVariantMap &data)
continue;
QList<OldStepMaps> oldSteps;
QList<QVariantMap> oldBuildConfigurations;
QList<Store> oldBuildConfigurations;
QString deployKey = "ProjectExplorer.Target.DeployConfiguration.";
for (int j = 0; j < deployconfigurationCount; ++j) {
QVariantMap deployConfigurationMap
Store deployConfigurationMap
= targetMap.value(deployKey + QString::number(j)).toMap();
OldStepMaps oldStep = extractStepMaps(deployConfigurationMap);
if (!oldStep.isEmpty()) {
@@ -672,17 +672,17 @@ QVariantMap UserFileVersion16Upgrader::upgrade(const QVariantMap &data)
QString bcKey = "ProjectExplorer.Target.BuildConfiguration.";
for (int j = 0; j < buildConfigurationCount; ++j) {
QVariantMap oldBuildConfigurationMap = targetMap.value(bcKey + QString::number(j)).toMap();
Store oldBuildConfigurationMap = targetMap.value(bcKey + QString::number(j)).toMap();
oldBuildConfigurations.append(oldBuildConfigurationMap);
}
QList<QVariantMap> newBuildConfigurations;
QList<Store> newBuildConfigurations;
NamePolicy policy = oldSteps.size() > 1 ? RenameBuildConfiguration : KeepName;
for (const QVariantMap &oldBuildConfiguration : std::as_const(oldBuildConfigurations)) {
for (const Store &oldBuildConfiguration : std::as_const(oldBuildConfigurations)) {
for (const OldStepMaps &oldStep : std::as_const(oldSteps)) {
QVariantMap newBuildConfiguration = insertSteps(oldBuildConfiguration, oldStep, policy);
Store newBuildConfiguration = insertSteps(oldBuildConfiguration, oldStep, policy);
if (!newBuildConfiguration.isEmpty())
newBuildConfigurations.append(newBuildConfiguration);
}
@@ -698,7 +698,7 @@ QVariantMap UserFileVersion16Upgrader::upgrade(const QVariantMap &data)
return result;
}
QVariantMap UserFileVersion17Upgrader::upgrade(const QVariantMap &map)
Store UserFileVersion17Upgrader::upgrade(const Store &map)
{
m_sticky = map.value(USER_STICKY_KEYS_KEY).toList();
if (m_sticky.isEmpty())
@@ -716,8 +716,8 @@ QVariant UserFileVersion17Upgrader::process(const QVariant &entry)
return result;
}
case QVariant::Map: {
QVariantMap result = entry.toMap();
for (QVariantMap::iterator i = result.begin(), end = result.end(); i != end; ++i) {
Store result = entry.toMap();
for (Store::iterator i = result.begin(), end = result.end(); i != end; ++i) {
QVariant &v = i.value();
v = process(v);
}
@@ -729,7 +729,7 @@ QVariant UserFileVersion17Upgrader::process(const QVariant &entry)
}
}
QVariantMap UserFileVersion18Upgrader::upgrade(const QVariantMap &map)
Store UserFileVersion18Upgrader::upgrade(const Store &map)
{
return process(map).toMap();
}
@@ -753,7 +753,7 @@ QVariant UserFileVersion18Upgrader::process(const QVariant &entry)
}
}
QVariantMap UserFileVersion19Upgrader::upgrade(const QVariantMap &map)
Store UserFileVersion19Upgrader::upgrade(const Store &map)
{
return process(map, QStringList()).toMap();
}
@@ -795,7 +795,7 @@ QVariant UserFileVersion19Upgrader::process(const QVariant &entry, const QString
return Utils::transform(entry.toList(),
std::bind(&UserFileVersion19Upgrader::process, std::placeholders::_1, path));
case QVariant::Map:
return Utils::transform<QVariantMap>(entry.toMap().toStdMap(),
return Utils::transform<Store>(entry.toMap().toStdMap(),
[&](const StringVariantPair &item) -> StringVariantPair {
if (path.size() == 2 && path.at(1).startsWith("ProjectExplorer.Target.RunConfiguration.")) {
if (argsKeys.contains(item.first))
@@ -818,7 +818,7 @@ QVariant UserFileVersion19Upgrader::process(const QVariant &entry, const QString
}
}
QVariantMap UserFileVersion20Upgrader::upgrade(const QVariantMap &map)
Store UserFileVersion20Upgrader::upgrade(const Store &map)
{
return process(map).toMap();
}
@@ -844,7 +844,7 @@ QVariant UserFileVersion20Upgrader::process(const QVariant &entry)
}
}
QVariantMap UserFileVersion21Upgrader::upgrade(const QVariantMap &map)
Store UserFileVersion21Upgrader::upgrade(const Store &map)
{
return process(map).toMap();
}
@@ -855,13 +855,13 @@ QVariant UserFileVersion21Upgrader::process(const QVariant &entry)
case QVariant::List:
return Utils::transform(entry.toList(), &UserFileVersion21Upgrader::process);
case QVariant::Map: {
QVariantMap entryMap = entry.toMap();
Store entryMap = entry.toMap();
if (entryMap.value("ProjectExplorer.ProjectConfiguration.Id").toString()
== "DeployToGenericLinux") {
entryMap.insert("_checkMakeInstall", true);
return entryMap;
}
return Utils::transform<QVariantMap>(
return Utils::transform<Store>(
entryMap.toStdMap(), [](const StringVariantPair &item) -> StringVariantPair{
return {item.first, UserFileVersion21Upgrader::process(item.second)};
});
@@ -884,7 +884,7 @@ class TestUserFileAccessor : public UserFileAccessor
public:
TestUserFileAccessor(Project *project) : UserFileAccessor(project) { }
void storeSharedSettings(const QVariantMap &data) const { m_storedSettings = data; }
void storeSharedSettings(const Store &data) const { m_storedSettings = data; }
QVariant retrieveSharedSettings() const override { return m_storedSettings; }
using UserFileAccessor::preprocessReadSettings;
@@ -893,7 +893,7 @@ public:
using UserFileAccessor::mergeSettings;
private:
mutable QVariantMap m_storedSettings;
mutable Store m_storedSettings;
};
@@ -912,11 +912,11 @@ void ProjectExplorerPlugin::testUserFileAccessor_prepareToReadSettings()
TestProject project;
TestUserFileAccessor accessor(&project);
QVariantMap data;
Store data;
data.insert("Version", 4);
data.insert("Foo", "bar");
QVariantMap result = accessor.preprocessReadSettings(data);
Store result = accessor.preprocessReadSettings(data);
QCOMPARE(result, data);
}
@@ -926,11 +926,11 @@ void ProjectExplorerPlugin::testUserFileAccessor_prepareToReadSettingsObsoleteVe
TestProject project;
TestUserFileAccessor accessor(&project);
QVariantMap data;
Store data;
data.insert("ProjectExplorer.Project.Updater.FileVersion", 4);
data.insert("Foo", "bar");
QVariantMap result = accessor.preprocessReadSettings(data);
Store result = accessor.preprocessReadSettings(data);
QCOMPARE(result.count(), data.count());
QCOMPARE(result.value("Foo"), data.value("Foo"));
@@ -942,12 +942,12 @@ void ProjectExplorerPlugin::testUserFileAccessor_prepareToReadSettingsObsoleteVe
TestProject project;
TestUserFileAccessor accessor(&project);
QVariantMap data;
Store data;
data.insert("ProjectExplorer.Project.Updater.FileVersion", 4);
data.insert("Version", 5);
data.insert("Foo", "bar");
QVariantMap result = accessor.preprocessReadSettings(data);
Store result = accessor.preprocessReadSettings(data);
QCOMPARE(result.count(), data.count() - 1);
QCOMPARE(result.value("Foo"), data.value("Foo"));
@@ -959,7 +959,7 @@ void ProjectExplorerPlugin::testUserFileAccessor_prepareToWriteSettings()
TestProject project;
TestUserFileAccessor accessor(&project);
QVariantMap sharedData;
Store sharedData;
sharedData.insert("Version", 10);
sharedData.insert("shared1", "bar");
sharedData.insert("shared2", "baz");
@@ -967,12 +967,12 @@ void ProjectExplorerPlugin::testUserFileAccessor_prepareToWriteSettings()
accessor.storeSharedSettings(sharedData);
QVariantMap data;
Store data;
data.insert("Version", 10);
data.insert("shared1", "bar1");
data.insert("unique1", 1234);
data.insert("shared3", "foo");
QVariantMap result = accessor.prepareToWriteSettings(data);
Store result = accessor.prepareToWriteSettings(data);
QCOMPARE(result.count(), data.count() + 3);
QCOMPARE(result.value("EnvironmentId").toByteArray(),
@@ -990,14 +990,14 @@ void ProjectExplorerPlugin::testUserFileAccessor_mergeSettings()
TestProject project;
TestUserFileAccessor accessor(&project);
QVariantMap sharedData;
Store sharedData;
sharedData.insert("Version", accessor.currentVersion());
sharedData.insert("shared1", "bar");
sharedData.insert("shared2", "baz");
sharedData.insert("shared3", "foooo");
TestUserFileAccessor::RestoreData shared("/shared/data", sharedData);
QVariantMap data;
Store data;
data.insert("Version", accessor.currentVersion());
data.insert("EnvironmentId", projectExplorerSettings().environmentId.toByteArray());
data.insert("UserStickyKeys", QStringList({"shared1"}));
@@ -1025,14 +1025,14 @@ void ProjectExplorerPlugin::testUserFileAccessor_mergeSettingsEmptyUser()
TestProject project;
TestUserFileAccessor accessor(&project);
QVariantMap sharedData;
Store sharedData;
sharedData.insert("Version", accessor.currentVersion());
sharedData.insert("shared1", "bar");
sharedData.insert("shared2", "baz");
sharedData.insert("shared3", "foooo");
TestUserFileAccessor::RestoreData shared("/shared/data", sharedData);
QVariantMap data;
Store data;
TestUserFileAccessor::RestoreData user("/shared/data", data);
TestUserFileAccessor::RestoreData result = accessor.mergeSettings(user, shared);
@@ -1046,10 +1046,10 @@ void ProjectExplorerPlugin::testUserFileAccessor_mergeSettingsEmptyShared()
TestProject project;
TestUserFileAccessor accessor(&project);
QVariantMap sharedData;
Store sharedData;
TestUserFileAccessor::RestoreData shared("/shared/data", sharedData);
QVariantMap data;
Store data;
data.insert("Version", accessor.currentVersion());
data.insert("OriginalVersion", accessor.currentVersion());
data.insert("EnvironmentId", projectExplorerSettings().environmentId.toByteArray());

12
src/plugins/projectexplorer/userfileaccessor.h
View File

@@ -3,11 +3,9 @@
#pragma once
#include <utils/fileutils.h>
#include <utils/settingsaccessor.h>
#include <QHash>
#include <QVariantMap>
#include <QMessageBox>
namespace ProjectExplorer {
@@ -30,12 +28,12 @@ public:
Utils::FilePath sharedFile() const;
protected:
QVariantMap postprocessMerge(const QVariantMap &main,
const QVariantMap &secondary,
const QVariantMap &result) const final;
Utils::Store postprocessMerge(const Utils::Store &main,
const Utils::Store &secondary,
const Utils::Store &result) const final;
QVariantMap preprocessReadSettings(const QVariantMap &data) const final;
QVariantMap prepareToWriteSettings(const QVariantMap &data) const final;
Utils::Store preprocessReadSettings(const Utils::Store &data) const final;
Utils::Store prepareToWriteSettings(const Utils::Store &data) const final;
Utils::SettingsMergeResult merge(const SettingsMergeData &global,
const SettingsMergeData &local) const final;