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

SdkTool: Use slightly less repetitive approach for operation interface

Browse Source 
Change-Id: I4d1d205c610df39be6a810dfda3049ae14a06806
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
Reviewed-by: Eike Ziller <eike.ziller@qt.io>
This commit is contained in:
hjk
2021-11-18 16:56:35 +01:00
parent f146b846cd
commit 44493857c2
31 changed files with 578 additions and 683 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
src/tools/sdktool/addabiflavor.cpp
View File

@@ -97,7 +97,7 @@ int AddAbiFlavor::execute() const
if (map.isEmpty())
map = initializeAbiFlavors();
QVariantMap result = addAbiFlavor(map, m_oses, m_flavor);
QVariantMap result = addAbiFlavor(map);
if (result.isEmpty() || result == map)
return 2;
@@ -113,7 +113,7 @@ bool AddAbiFlavor::test() const
|| !map.contains(QLatin1String(VERSION)))
return false;
map = addAbiFlavor(map, {"linux", "windows"}, "foo");
map = AddAbiFlavorData{{"linux", "windows"}, "foo"}.addAbiFlavor(map);
if (map.count() != 2
|| !map.contains(QLatin1String(VERSION))
@@ -126,7 +126,7 @@ bool AddAbiFlavor::test() const
return false;
// Ignore known flavors:
const QVariantMap result = addAbiFlavor(map, {"linux"}, "foo");
const QVariantMap result = AddAbiFlavorData({{"linux"}, "foo"}).addAbiFlavor(map);;
if (map != result)
return false;
@@ -135,37 +135,35 @@ bool AddAbiFlavor::test() const
}
#endif
QVariantMap AddAbiFlavor::addAbiFlavor(const QVariantMap &map,
const QStringList &oses,
const QString &flavor)
QVariantMap AddAbiFlavorData::addAbiFlavor(const QVariantMap &map) const
{
// Sanity check: Is flavor already set in abi file?
if (exists(map, flavor)) {
std::cerr << "Error: flavor " << qPrintable(flavor) << " already defined as extra ABI flavor." << std::endl;
if (exists(map, m_flavor)) {
std::cerr << "Error: flavor " << qPrintable(m_flavor) << " already defined as extra ABI flavor." << std::endl;
return map;
}
QVariantMap result = map;
QVariantMap flavorMap = map.value(QLatin1String(FLAVORS)).toMap();
flavorMap.insert(flavor, oses);
flavorMap.insert(m_flavor, m_oses);
result.insert(QLatin1String(FLAVORS), flavorMap);
return result;
}
QVariantMap AddAbiFlavor::initializeAbiFlavors()
QVariantMap AddAbiFlavorData::initializeAbiFlavors()
{
QVariantMap map;
map.insert(QLatin1String(VERSION), 1);
return map;
}
bool AddAbiFlavor::exists(const QString &flavor)
bool AddAbiFlavorData::exists(const QString &flavor)
{
QVariantMap map = load(QLatin1String(ABI_FILE_ID));
QVariantMap map = Operation::load(QLatin1String(ABI_FILE_ID));
return exists(map, flavor);
}
bool AddAbiFlavor::exists(const QVariantMap &map, const QString &flavor)
bool AddAbiFlavorData::exists(const QVariantMap &map, const QString &flavor)
{
const QVariantMap flavorMap = map.value(QLatin1String(FLAVORS)).toMap();
return flavorMap.contains(flavor);

36
src/tools/sdktool/addabiflavor.h
View File

@@ -27,32 +27,32 @@
#include "operation.h"
#include <QString>
class AddAbiFlavor : public Operation
class AddAbiFlavorData
{
public:
QString name() const;
QString helpText() const;
QString argumentsHelpText() const;
bool setArguments(const QStringList &args);
int execute() const;
#ifdef WITH_TESTS
bool test() const;
#endif
static QVariantMap addAbiFlavor(const QVariantMap &map,
const QStringList &oses, const QString &flavor);
QVariantMap addAbiFlavor(const QVariantMap &map) const;
static QVariantMap initializeAbiFlavors();
static bool exists(const QString &flavor);
static bool exists(const QVariantMap &map, const QString &flavor);
private:
QStringList m_oses;
QString m_flavor;
};
class AddAbiFlavor : public Operation, public AddAbiFlavorData
{
public:
QString name() const final;
QString helpText() const final;
QString argumentsHelpText() const final;
bool setArguments(const QStringList &args) final;
int execute() const final;
#ifdef WITH_TESTS
bool test() const final;
#endif
};

37
src/tools/sdktool/addcmakeoperation.cpp
View File

@@ -122,7 +122,7 @@ int AddCMakeOperation::execute() const
if (map.isEmpty())
map = initializeCMake();
QVariantMap result = addCMake(map, m_id, m_displayName, m_path, m_extra);
QVariantMap result = addCMake(map);
if (result.isEmpty() || map == result)
return 2;
@@ -135,8 +135,7 @@ bool AddCMakeOperation::test() const
QVariantMap map = initializeCMake();
// Add toolchain:
map = addCMake(map, "testId", "name", "/tmp/test",
KeyValuePairList() << KeyValuePair("ExtraKey", QVariant("ExtraValue")));
map = AddCMakeData{"testId", "name", "/tmp/test", {{"ExtraKey", QVariant("ExtraValue")}}}.addCMake(map);
if (map.value(COUNT).toInt() != 1
|| !map.contains(QString::fromLatin1(PREFIX) + '0'))
return false;
@@ -150,14 +149,14 @@ bool AddCMakeOperation::test() const
return false;
// Ignore same Id:
QVariantMap unchanged = addCMake(map, "testId", "name2", "/tmp/test2",
KeyValuePairList() << KeyValuePair("ExtraKey", QVariant("ExtraValue2")));
QVariantMap unchanged = AddCMakeData{"testId", "name2", "/tmp/test2", {{"ExtraKey", QVariant("ExtraValue2")}}}
.addCMake(map);
if (!unchanged.isEmpty())
return false;
// add 2nd cmake
map = addCMake(map, "{some-cm-id}", "name", "/tmp/test",
KeyValuePairList() << KeyValuePair("ExtraKey", QVariant("ExtraValue")));
map = AddCMakeData{"{some-cm-id}", "name", "/tmp/test", {{"ExtraKey", QVariant("ExtraValue")}}}
.addCMake(map);
if (map.value(COUNT).toInt() != 2
|| !map.contains(QString::fromLatin1(PREFIX) + '0')
|| !map.contains(QString::fromLatin1(PREFIX) + '1'))
@@ -183,13 +182,11 @@ bool AddCMakeOperation::test() const
}
#endif
QVariantMap AddCMakeOperation::addCMake(const QVariantMap &map, const QString &id,
const QString &displayName, const QString &path,
const KeyValuePairList &extra)
QVariantMap AddCMakeData::addCMake(const QVariantMap &map) const
{
// Sanity check: Does the Id already exist?
if (exists(map, id)) {
std::cerr << "Error: Id " << qPrintable(id) << " already defined for tool chains." << std::endl;
if (exists(map, m_id)) {
std::cerr << "Error: Id " << qPrintable(m_id) << " already defined for tool chains." << std::endl;
return QVariantMap();
}
@@ -206,20 +203,20 @@ QVariantMap AddCMakeOperation::addCMake(const QVariantMap &map, const QString &i
const QString cm = QString::fromLatin1(PREFIX) + QString::number(count);
KeyValuePairList data;
data << KeyValuePair({cm, ID_KEY}, QVariant(id));
data << KeyValuePair({cm, DISPLAYNAME_KEY}, QVariant(displayName));
data << KeyValuePair({cm, ID_KEY}, QVariant(m_id));
data << KeyValuePair({cm, DISPLAYNAME_KEY}, QVariant(m_displayName));
data << KeyValuePair({cm, AUTODETECTED_KEY}, QVariant(true));
data << KeyValuePair({cm, PATH_KEY}, Utils::FilePath::fromUserInput(path).toVariant());
data << KeyValuePair({cm, PATH_KEY}, Utils::FilePath::fromUserInput(m_path).toVariant());
KeyValuePairList extraList;
foreach (const KeyValuePair &pair, extra)
foreach (const KeyValuePair &pair, m_extra)
extraList << KeyValuePair(QStringList({cm}) << pair.key, pair.value);
data.append(extraList);
data << KeyValuePair(COUNT, QVariant(count + 1));
return AddKeysOperation::addKeys(result, data);
return AddKeysData{data}.addKeys(result);
}
QVariantMap AddCMakeOperation::initializeCMake()
QVariantMap AddCMakeData::initializeCMake()
{
QVariantMap map;
map.insert(COUNT, 0);
@@ -227,7 +224,7 @@ QVariantMap AddCMakeOperation::initializeCMake()
return map;
}
bool AddCMakeOperation::exists(const QVariantMap &map, const QString &id)
bool AddCMakeData::exists(const QVariantMap &map, const QString &id)
{
QStringList valueKeys = FindValueOperation::findValue(map, id);
// support old settings using QByteArray for id's
@@ -241,7 +238,7 @@ bool AddCMakeOperation::exists(const QVariantMap &map, const QString &id)
return false;
}
bool AddCMakeOperation::exists(const QString &id)
bool AddCMakeData::exists(const QString &id)
{
QVariantMap map = Operation::load("cmaketools");
return exists(map, id);

38
src/tools/sdktool/addcmakeoperation.h
View File

@@ -27,34 +27,34 @@
#include "operation.h"
#include <QString>
class AddCMakeOperation : public Operation
class AddCMakeData
{
public:
QString name() const;
QString helpText() const;
QString argumentsHelpText() const;
bool setArguments(const QStringList &args);
int execute() const;
#ifdef WITH_TESTS
bool test() const;
#endif
static QVariantMap addCMake(const QVariantMap &map, const QString &id,
const QString &displayName, const QString &path,
const KeyValuePairList &extra);
QVariantMap addCMake(const QVariantMap &map) const;
static QVariantMap initializeCMake();
static bool exists(const QString &id);
static bool exists(const QVariantMap &map, const QString &id);
private:
QString m_id;
QString m_displayName;
QString m_path;
KeyValuePairList m_extra;
};
class AddCMakeOperation : public Operation, public AddCMakeData
{
public:
QString name() const final;
QString helpText() const final;
QString argumentsHelpText() const final;
bool setArguments(const QStringList &args) final;
int execute() const final;
#ifdef WITH_TESTS
bool test() const final;
#endif
};

28
src/tools/sdktool/adddebuggeroperation.cpp
View File

@@ -144,8 +144,7 @@ int AddDebuggerOperation::execute() const
if (map.isEmpty())
map = initializeDebuggers();
QVariantMap result = addDebugger(map, m_id, m_displayName, m_engine, m_binary, m_abis,
m_extra);
QVariantMap result = addDebugger(map);
if (result.isEmpty() || map == result)
return 2;
@@ -169,13 +168,10 @@ bool AddDebuggerOperation::test() const
}
#endif
QVariantMap AddDebuggerOperation::addDebugger(const QVariantMap &map,
const QString &id, const QString &displayName,
int engine, const QString &binary,
const QStringList &abis, const KeyValuePairList &extra)
QVariantMap AddDebuggerData::addDebugger(const QVariantMap &map) const
{
// Sanity check: Make sure autodetection source is not in use already:
QStringList valueKeys = FindValueOperation::findValue(map, QVariant(id));
QStringList valueKeys = FindValueOperation::findValue(map, QVariant(m_id));
bool hasId = false;
foreach (const QString &k, valueKeys) {
if (k.endsWith(QString(QLatin1Char('/')) + QLatin1String(ID))) {
@@ -184,7 +180,7 @@ QVariantMap AddDebuggerOperation::addDebugger(const QVariantMap &map,
}
}
if (hasId) {
std::cerr << "Error: Id " << qPrintable(id) << " already defined as debugger." << std::endl;
std::cerr << "Error: Id " << qPrintable(m_id) << " already defined as debugger." << std::endl;
return QVariantMap();
}
@@ -204,27 +200,27 @@ QVariantMap AddDebuggerOperation::addDebugger(const QVariantMap &map,
// insert data:
KeyValuePairList data;
data << KeyValuePair(QStringList() << debugger << QLatin1String(ID), QVariant(id));
data << KeyValuePair(QStringList() << debugger << QLatin1String(ID), QVariant(m_id));
data << KeyValuePair(QStringList() << debugger << QLatin1String(DISPLAYNAME),
QVariant(displayName));
QVariant(m_displayName));
data << KeyValuePair(QStringList() << debugger << QLatin1String(AUTODETECTED), QVariant(true));
data << KeyValuePair(QStringList() << debugger << QLatin1String(ABIS), QVariant(abis));
data << KeyValuePair(QStringList() << debugger << QLatin1String(ENGINE_TYPE), QVariant(engine));
data << KeyValuePair(QStringList() << debugger << QLatin1String(ABIS), QVariant(m_abis));
data << KeyValuePair(QStringList() << debugger << QLatin1String(ENGINE_TYPE), QVariant(m_engine));
data << KeyValuePair(QStringList() << debugger << QLatin1String(BINARY),
Utils::FilePath::fromUserInput(binary).toVariant());
Utils::FilePath::fromUserInput(m_binary).toVariant());
data << KeyValuePair(QStringList() << QLatin1String(COUNT), QVariant(count + 1));
KeyValuePairList qtExtraList;
foreach (const KeyValuePair &pair, extra)
foreach (const KeyValuePair &pair, m_extra)
qtExtraList << KeyValuePair(QStringList() << debugger << pair.key, pair.value);
data.append(qtExtraList);
return AddKeysOperation::addKeys(cleaned, data);
return AddKeysData{data}.addKeys(cleaned);
}
QVariantMap AddDebuggerOperation::initializeDebuggers()
QVariantMap AddDebuggerData::initializeDebuggers()
{
QVariantMap map;
map.insert(QLatin1String(VERSION), 1);

38
src/tools/sdktool/adddebuggeroperation.h
View File

@@ -27,31 +27,13 @@
#include "operation.h"
#include <QString>
class AddDebuggerOperation : public Operation
class AddDebuggerData
{
public:
QString name() const;
QString helpText() const;
QString argumentsHelpText() const;
bool setArguments(const QStringList &args);
int execute() const;
#ifdef WITH_TESTS
bool test() const;
#endif
static QVariantMap addDebugger(const QVariantMap &map,
const QString &id, const QString &displayName,
int engine, const QString &binary,
const QStringList &abis, const KeyValuePairList &extra);
QVariantMap addDebugger(const QVariantMap &map) const;
static QVariantMap initializeDebuggers();
private:
QString m_id;
QString m_displayName;
int m_engine = 0;
@@ -59,3 +41,19 @@ private:
QStringList m_abis;
KeyValuePairList m_extra;
};
class AddDebuggerOperation : public Operation, public AddDebuggerData
{
public:
QString name() const final;
QString helpText() const final;
QString argumentsHelpText() const final;
bool setArguments(const QStringList &args) final;
int execute() const final;
#ifdef WITH_TESTS
bool test() const final;
#endif
};

103
src/tools/sdktool/adddeviceoperation.cpp
View File

@@ -247,10 +247,7 @@ int AddDeviceOperation::execute() const
if (map.isEmpty())
map = initializeDevices();
QVariantMap result = addDevice(map, m_id, m_displayName, m_type, m_authentication,
m_b2q_platformHardware, m_b2q_platformSoftware, m_debugServer,
m_freePortsSpec, m_host, m_keyFile, m_origin, m_osType,
m_password, m_sshPort, m_timeout, m_uname, m_version, m_extra);
QVariantMap result = addDevice(map);
if (result.isEmpty() || map == result)
return 2;
@@ -263,13 +260,15 @@ bool AddDeviceOperation::test() const
{
QVariantMap map = initializeDevices();
QVariantMap result = addDevice(map, QLatin1String("test id"), QLatin1String("test name"),
1, 2, QLatin1String("HW"), QLatin1String("SW"),
QLatin1String("debugServer"), QLatin1String("ports"),
QLatin1String("host"), QLatin1String("keyfile"), 3,
QLatin1String("ostype"), QLatin1String("passwd"), 4, 5,
QLatin1String("uname"), 6, KeyValuePairList());
AddDeviceData devData = {
QLatin1String("test id"), QLatin1String("test name"),
1, 2, QLatin1String("HW"), QLatin1String("SW"),
QLatin1String("debugServer"), QLatin1String("ports"),
QLatin1String("host"), QLatin1String("keyfile"), 3,
QLatin1String("ostype"), QLatin1String("passwd"), 4, 5,
QLatin1String("uname"), 6, KeyValuePairList()
};
QVariantMap result = devData.addDevice(map);
QVariantMap data = result.value(QLatin1String(DEVICEMANAGER_ID)).toMap();
QVariantList devList = data.value(QLatin1String(DEVICE_LIST_ID)).toList();
if (devList.count() != 1)
@@ -312,30 +311,38 @@ bool AddDeviceOperation::test() const
}
#endif
QVariantMap AddDeviceOperation::addDevice(const QVariantMap &map,
const QString &id, const QString &displayName, int type,
int auth, const QString &hwPlatform, const QString &swPlatform,
const QString &debugServer, const QString &freePorts,
const QString &host, const QString &keyFile,
int origin, const QString &osType, const QString &passwd,
int sshPort, int timeout, const QString &uname, int version,
const KeyValuePairList &extra)
QVariantMap AddDeviceData::addDevice(const QVariantMap &map) const
{
QVariantMap result = map;
if (exists(map, id)) {
std::cerr << "Device " << qPrintable(id) << " already exists!" << std::endl;
if (exists(map, m_id)) {
std::cerr << "Device " << qPrintable(m_id) << " already exists!" << std::endl;
return result;
}
QVariantMap dmMap = map.value(QLatin1String(DEVICEMANAGER_ID)).toMap();
QVariantList devList = dmMap.value(QLatin1String(DEVICE_LIST_ID)).toList();
QVariantMap devMap
= AddKeysOperation::addKeys(QVariantMap(),
createDevice(id, displayName, type, auth, hwPlatform,
swPlatform, debugServer, freePorts, host,
keyFile, origin, osType, passwd, sshPort,
timeout, uname, version, extra));
KeyValuePairList dev;
dev.append(KeyValuePair(QLatin1String(DEVICE_ID_ID), QVariant(m_id)));
dev.append(KeyValuePair(QLatin1String("Name"), QVariant(m_displayName)));
dev.append(KeyValuePair(QLatin1String("Type"), QVariant(m_type)));
dev.append(KeyValuePair(QLatin1String("Authentication"), QVariant(m_authentication)));
dev.append(KeyValuePair(QLatin1String("Boot2Qt.PlatformInfoHardware"), QVariant(m_b2q_platformHardware)));
dev.append(KeyValuePair(QLatin1String("Boot2Qt.PlatformInfoSoftware"), QVariant(m_b2q_platformSoftware)));
dev.append(KeyValuePair(QLatin1String("DebugServerKey"), QVariant(m_debugServer)));
dev.append(KeyValuePair(QLatin1String("FreePortsSpec"), QVariant(m_freePortsSpec)));
dev.append(KeyValuePair(QLatin1String("Host"), QVariant(m_host)));
dev.append(KeyValuePair(QLatin1String("KeyFile"), QVariant(m_keyFile)));
dev.append(KeyValuePair(QLatin1String("Origin"), QVariant(m_origin)));
dev.append(KeyValuePair(QLatin1String("OsType"), QVariant(m_osType)));
dev.append(KeyValuePair(QLatin1String("Password"), QVariant(m_password)));
dev.append(KeyValuePair(QLatin1String("SshPort"), QVariant(m_sshPort)));
dev.append(KeyValuePair(QLatin1String("Timeout"), QVariant(m_timeout)));
dev.append(KeyValuePair(QLatin1String("Uname"), QVariant(m_uname)));
dev.append(KeyValuePair(QLatin1String("Version"), QVariant(m_version)));
dev.append(m_extra);
QVariantMap devMap = AddKeysData{dev}.addKeys(QVariantMap());
devList.append(devMap);
@@ -346,7 +353,7 @@ QVariantMap AddDeviceOperation::addDevice(const QVariantMap &map,
return result;
}
QVariantMap AddDeviceOperation::initializeDevices()
QVariantMap AddDeviceData::initializeDevices()
{
QVariantMap dmData;
dmData.insert(QLatin1String(DEFAULT_DEVICES_ID), QVariantMap());
@@ -357,13 +364,13 @@ QVariantMap AddDeviceOperation::initializeDevices()
return data;
}
bool AddDeviceOperation::exists(const QString &id)
bool AddDeviceData::exists(const QString &id)
{
QVariantMap map = load(QLatin1String("Devices"));
QVariantMap map = Operation::load(QLatin1String("Devices"));
return exists(map, id);
}
bool AddDeviceOperation::exists(const QVariantMap &map, const QString &id)
bool AddDeviceData::exists(const QVariantMap &map, const QString &id)
{
if (id == QLatin1String(INTERNAL_DSEKTOP_DEVICE_ID))
return true;
@@ -377,37 +384,3 @@ bool AddDeviceOperation::exists(const QVariantMap &map, const QString &id)
}
return false;
}
Operation::KeyValuePairList AddDeviceOperation::createDevice(const QString &id, const QString &displayName,
int type, int auth, const QString &hwPlatform,
const QString &swPlatform, const QString &debugServer,
const QString &freePorts, const QString &host,
const QString &keyFile, int origin,
const QString &osType, const QString &passwd,
int sshPort, int timeout, const QString &uname,
int version, const Operation::KeyValuePairList &extra)
{
Operation::KeyValuePairList dev;
dev.append(KeyValuePair(QLatin1String(DEVICE_ID_ID), QVariant(id)));
dev.append(KeyValuePair(QLatin1String("Name"), QVariant(displayName)));
dev.append(KeyValuePair(QLatin1String("Type"), QVariant(type)));
dev.append(KeyValuePair(QLatin1String("Authentication"), QVariant(auth)));
dev.append(KeyValuePair(QLatin1String("Boot2Qt.PlatformInfoHardware"), QVariant(hwPlatform)));
dev.append(KeyValuePair(QLatin1String("Boot2Qt.PlatformInfoSoftware"), QVariant(swPlatform)));
dev.append(KeyValuePair(QLatin1String("DebugServerKey"), QVariant(debugServer)));
dev.append(KeyValuePair(QLatin1String("FreePortsSpec"), QVariant(freePorts)));
dev.append(KeyValuePair(QLatin1String("Host"), QVariant(host)));
dev.append(KeyValuePair(QLatin1String("KeyFile"), QVariant(keyFile)));
dev.append(KeyValuePair(QLatin1String("Origin"), QVariant(origin)));
dev.append(KeyValuePair(QLatin1String("OsType"), QVariant(osType)));
dev.append(KeyValuePair(QLatin1String("Password"), QVariant(passwd)));
dev.append(KeyValuePair(QLatin1String("SshPort"), QVariant(sshPort)));
dev.append(KeyValuePair(QLatin1String("Timeout"), QVariant(timeout)));
dev.append(KeyValuePair(QLatin1String("Uname"), QVariant(uname)));
dev.append(KeyValuePair(QLatin1String("Version"), QVariant(version)));
dev.append(extra);
return dev;
}

54
src/tools/sdktool/adddeviceoperation.h
View File

@@ -35,60 +35,48 @@ extern const char DEVICE_LIST_ID[];
extern const char DEVICE_ID_ID[];
class AddDeviceOperation : public Operation
class AddDeviceData
{
public:
QString name() const;
QString helpText() const;
QString argumentsHelpText() const;
bool setArguments(const QStringList &args);
int execute() const;
#ifdef WITH_TESTS
bool test() const;
#endif
static QVariantMap addDevice(const QVariantMap &map,
const QString &id, const QString &displayName, int type,
int auth, const QString &hwPlatform, const QString &swPlatform,
const QString &debugServer, const QString &freePorts,
const QString &host, const QString &keyFile,
int origin, const QString &osType, const QString &passwd,
int sshPort, int timeout, const QString &uname, int version,
const KeyValuePairList &extra);
QVariantMap addDevice(const QVariantMap &map) const;
static QVariantMap initializeDevices();
static bool exists(const QString &id);
static bool exists(const QVariantMap &map, const QString &id);
private:
static KeyValuePairList createDevice(const QString &id, const QString &displayName, int type,
int auth, const QString &hwPlatform, const QString &swPlatform,
const QString &debugServer, const QString &freePorts,
const QString &host, const QString &keyFile,
int origin, const QString &osType, const QString &passwd,
int sshPort, int timeout, const QString &uname, int version,
const KeyValuePairList &extra);
QString m_id;
QString m_displayName;
int m_type = -1;
int m_authentication = -1;
QString m_b2q_platformHardware;
QString m_b2q_platformSoftware;
QString m_debugServer;
QString m_freePortsSpec;
QString m_host;
QString m_id;
QString m_keyFile;
QString m_displayName;
int m_origin = 1;
QString m_osType;
QString m_password;
int m_sshPort = 0;
int m_timeout = 5;
int m_type = -1;
QString m_uname;
int m_version = 0;
KeyValuePairList m_extra;
};
class AddDeviceOperation : public Operation, public AddDeviceData
{
public:
QString name() const final;
QString helpText() const final;
QString argumentsHelpText() const final;
bool setArguments(const QStringList &args) final;
int execute() const final;
#ifdef WITH_TESTS
bool test() const final;
#endif
};

14
src/tools/sdktool/addkeysoperation.cpp
View File

@@ -76,7 +76,7 @@ int AddKeysOperation::execute() const
QVariantMap map = load(m_file);
QVariantMap result = addKeys(map, m_data);
QVariantMap result = addKeys(map);
if (result.isEmpty() || map == result)
return 4;
@@ -108,7 +108,7 @@ bool AddKeysOperation::test() const
data.append(KeyValuePair(QLatin1String("newsub/1/2/3/qbytearray"), QString::fromLatin1("QByteArray:test array.")));
data.append(KeyValuePair(QLatin1String("newsub/1/2.1/3/qbytearray"), QString::fromLatin1("QByteArray:test array.")));
QVariantMap result = addKeys(testMap, data);
QVariantMap result = AddKeysData{data}.addKeys(testMap);
if (result.count() != 9)
return false;
@@ -194,13 +194,13 @@ bool AddKeysOperation::test() const
// preexisting:
data.clear();
data.append(KeyValuePair(QLatin1String("testint"), QString::fromLatin1("int:4")));
result = addKeys(testMap, data);
result = AddKeysData{data}.addKeys(testMap);
if (!result.isEmpty())
return false;
data.clear();
data.append(KeyValuePair(QLatin1String("subkeys/testbool"), QString::fromLatin1("int:24")));
result = addKeys(testMap, data);
result = AddKeysData{data}.addKeys(testMap);
if (!result.isEmpty())
return false;
@@ -208,7 +208,7 @@ bool AddKeysOperation::test() const
data.clear();
data.append(KeyValuePair(QLatin1String("bool-true"), QString::fromLatin1("bool:trUe")));
data.append(KeyValuePair(QLatin1String("bool-true"), QString::fromLatin1("bool:trUe")));
result = addKeys(testMap, data);
result = AddKeysData{data}.addKeys(testMap);
if (!result.isEmpty())
return false;
@@ -216,12 +216,12 @@ bool AddKeysOperation::test() const
}
#endif
QVariantMap AddKeysOperation::addKeys(const QVariantMap &map, const KeyValuePairList &additions)
QVariantMap AddKeysData::addKeys(const QVariantMap &map) const
{
// Insert data:
QVariantMap result = map;
foreach (const KeyValuePair &p, additions) {
foreach (const KeyValuePair &p, m_data) {
QList<QVariantMap> stack;
// Set up a stack of QVariantMaps along the path we take:

38
src/tools/sdktool/addkeysoperation.h
View File

@@ -27,25 +27,29 @@
#include "operation.h"
class AddKeysOperation : public Operation
class AddKeysData
{
public:
QString name() const;
QString helpText() const;
QString argumentsHelpText() const;
bool setArguments(const QStringList &args);
int execute() const;
#ifdef WITH_TESTS
bool test() const;
#endif
static QVariantMap addKeys(const QVariantMap &map, const KeyValuePairList &additions);
private:
QString m_file;
QVariantMap addKeys(const QVariantMap &map) const;
QList<KeyValuePair> m_data;
};
class AddKeysOperation : public Operation, public AddKeysData
{
public:
QString name() const final;
QString helpText() const final;
QString argumentsHelpText() const final;
bool setArguments(const QStringList &args) final;
int execute() const final;
#ifdef WITH_TESTS
bool test() const final;
#endif
private:
QString m_file;
};

284
src/tools/sdktool/addkitoperation.cpp
View File

@@ -293,12 +293,7 @@ int AddKitOperation::execute() const
if (map.isEmpty())
map = initializeKits();
QVariantMap result = addKit(map, m_id, m_displayName, m_icon, m_debuggerId, m_debuggerEngine,
m_debugger, m_deviceType, m_device, m_sysRoot, m_tcs, m_qt,
m_mkspec, m_cmakeId, m_cmakeGenerator, m_cmakeExtraGenerator,
m_cmakeGeneratorToolset, m_cmakeGeneratorPlatform, m_cmakeConfiguration,
m_env, m_extra);
const QVariantMap result = addKit(map);
if (result.isEmpty() || map == result)
return 2;
@@ -308,26 +303,26 @@ int AddKitOperation::execute() const
#ifdef WITH_TESTS
bool AddKitOperation::test() const
{
AddKitData kitData;
QVariantMap map = initializeKits();
QVariantMap tcMap = AddToolChainOperation::initializeToolChains();
tcMap = AddToolChainOperation::addToolChain(tcMap, "{tc-id}", "langId", "TC", "/usr/bin/gcc",
"x86-linux-generic-elf-32bit",
"x86-linux-generic-elf-32bit",
KeyValuePairList());
QVariantMap tcMap = AddToolChainData::initializeToolChains();
tcMap = AddToolChainData{"{tc-id}", "langId", "TC", "/usr/bin/gcc",
"x86-linux-generic-elf-32bit", "x86-linux-generic-elf-32bit", {}}
.addToolChain(tcMap);
QVariantMap qtMap = AddQtOperation::initializeQtVersions();
qtMap = AddQtOperation::addQt(qtMap, "{qt-id}", "Qt", "desktop-qt", "/usr/bin/qmake",
KeyValuePairList(), {});
QVariantMap qtMap = AddQtData::initializeQtVersions();
qtMap = AddQtData{"{qt-id}", "Qt", "desktop-qt", "/usr/bin/qmake", {}, {}}.addQt(qtMap);
QVariantMap devMap = AddDeviceOperation::initializeDevices();
devMap = AddDeviceOperation::addDevice(devMap, "{dev-id}", "Dev", 0, 0,
"HWplatform", "SWplatform",
"localhost", "10000-11000",
"localhost", "", 42,
"desktop", "", 22, 10000,
"uname", 1,
KeyValuePairList());
devMap = AddDeviceData{"{dev-id}", "Dev", 0, 0,
"HWplatform", "SWplatform",
"localhost", "10000-11000",
"localhost", "", 42,
"desktop", "", 22, 10000,
"uname", 1,
KeyValuePairList()}
.addDevice(devMap);
const QStringList env = {"TEST=1", "PATH"};
@@ -341,34 +336,35 @@ bool AddKitOperation::test() const
tcs.insert("Cxx", "{tcXX-id}");
// Fail if TC is not there:
QVariantMap empty = addKit(map, tcMap, qtMap, devMap, QVariantMap(),
"testId", "Test Kit", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", "{dev-id}", QString(),
tcs, "{qt-id}", "unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(),
QStringList(),
KeyValuePairList({KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue"))}));
kitData = {"testId", "Test Kit", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", "{dev-id}", QString(),
tcs, "{qt-id}", "unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(),
QStringList(),
{{{"PE.Profile.Data/extraData", QVariant("extraValue")}}}};
QVariantMap empty = kitData.addKit(map, tcMap, qtMap, devMap, {});
if (!empty.isEmpty())
return false;
// Do not fail if TC is an ABI:
tcs.clear();
tcs.insert("C", "x86-linux-generic-elf-64bit");
empty = addKit(map, tcMap, qtMap, devMap, QVariantMap(),
"testId", "Test Kit", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", "{dev-id}", QString(),
tcs, "{qt-id}", "unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(), env,
KeyValuePairList({KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue"))}));
kitData = {"testId", "Test Kit", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", "{dev-id}", QString(),
tcs, "{qt-id}", "unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(), env,
{KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue"))}};
empty = kitData.addKit(map, tcMap, qtMap, devMap, {});
if (empty.isEmpty())
return false;
// QTCREATORBUG-11983, mach_o was not covered by the first attempt to fix this.
tcs.insert("D", "x86-macos-generic-mach_o-64bit");
empty = addKit(map, tcMap, qtMap, devMap, QVariantMap(),
"testId", "Test Kit", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", "{dev-id}", QString(),
tcs, "{qt-id}", "unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(), env,
KeyValuePairList({KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue"))}));
kitData = {"testId", "Test Kit", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", "{dev-id}", QString(),
tcs, "{qt-id}", "unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(), env,
{{KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue"))}}};
empty = kitData.addKit(map, tcMap, qtMap, devMap, {});
if (empty.isEmpty())
return false;
@@ -376,31 +372,31 @@ bool AddKitOperation::test() const
tcs.insert("Cxx", "{tc-id}");
// Fail if Qt is not there:
empty = addKit(map, tcMap, qtMap, devMap, QVariantMap(),
"testId", "Test Kit", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", "{dev-id}", QString(), tcs, "{qtXX-id}",
"unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(), env,
KeyValuePairList({KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue"))}));
kitData = {"testId", "Test Kit", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", "{dev-id}", QString(), tcs, "{qtXX-id}",
"unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(), env,
{{KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue"))}}};
empty = kitData.addKit(map, tcMap, qtMap, devMap, {});
if (!empty.isEmpty())
return false;
// Fail if dev is not there:
empty = addKit(map, tcMap, qtMap, devMap, QVariantMap(),
"testId", "Test Kit", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", "{devXX-id}", QString(), tcs, "{qt-id}",
"unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(), env,
KeyValuePairList({KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue"))}));
kitData = {"testId", "Test Kit", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", "{devXX-id}", QString(), tcs, "{qt-id}",
"unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(), env,
{KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue"))}};
empty = kitData.addKit(map, tcMap, qtMap, devMap, {});
if (!empty.isEmpty())
return false;
// Profile 0:
map = addKit(map, tcMap, qtMap, devMap, QVariantMap(),
"testId", "Test Kit", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", QString(), QString(), tcs, "{qt-id}",
"unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(), env,
KeyValuePairList({KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue"))}));
kitData = {"testId", "Test Kit", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", QString(), QString(), tcs, "{qt-id}",
"unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(), env,
{{KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue"))}}};
map = kitData.addKit(map, tcMap, qtMap, devMap, {});
if (map.count() != 4
|| !map.contains(VERSION) || map.value(VERSION).toInt() != 1
@@ -434,22 +430,23 @@ bool AddKitOperation::test() const
return false;
// Ignore existing ids:
QVariantMap result = addKit(map, tcMap, qtMap, devMap, QVariantMap(),
"testId", "Test Qt Version X",
"/tmp/icon3.png", QString(), 1, "/usr/bin/gdb-test3", "Desktop",
QString(), QString(), tcs, "{qt-id}", "unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(), env,
KeyValuePairList({KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue"))}));
kitData = {"testId", "Test Qt Version X",
"/tmp/icon3.png", QString(), 1, "/usr/bin/gdb-test3", "Desktop",
QString(), QString(), tcs, "{qt-id}", "unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(), env,
{{KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue"))}}};
QVariantMap result = kitData.addKit(map, tcMap, qtMap, devMap, {});
if (!result.isEmpty())
return false;
// Profile 1: Make sure name is unique:
map = addKit(map, tcMap, qtMap, devMap, QVariantMap(),
"testId2", "Test Kit2", "/tmp/icon2.png", QString(), 1,
"/usr/bin/gdb-test2", "Desktop", "{dev-id}", "/sys/root//", tcs,
"{qt-id}", "unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(), env,
KeyValuePairList({KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue"))}));
kitData = {"testId2", "Test Kit2", "/tmp/icon2.png", QString(), 1,
"/usr/bin/gdb-test2", "Desktop", "{dev-id}", "/sys/root//", tcs,
"{qt-id}", "unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(), env,
{{KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue"))}}};
map = kitData.addKit(map, tcMap, qtMap, devMap, {});
if (map.count() != 5
|| !map.contains(VERSION) || map.value(VERSION).toInt() != 1
|| !map.contains(COUNT) || map.value(COUNT).toInt() != 2
@@ -489,12 +486,12 @@ bool AddKitOperation::test() const
return false;
// Profile 2: Test debugger id:
map = addKit(map, tcMap, qtMap, devMap, QVariantMap(),
"test with debugger Id", "Test debugger Id",
"/tmp/icon2.png", "debugger Id", 0, QString(), "Desktop", QString(), QString(),
tcs, "{qt-id}", "unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(), env,
KeyValuePairList({KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue"))}));
kitData = {"test with debugger Id", "Test debugger Id",
"/tmp/icon2.png", "debugger Id", 0, QString(), "Desktop", QString(), QString(),
tcs, "{qt-id}", "unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(), env,
{KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue"))}};
map = kitData.addKit(map, tcMap, qtMap, devMap, {});
if (map.count() != 6
|| !map.contains(VERSION) || map.value(VERSION).toInt() != 1
|| !map.contains(COUNT) || map.value(COUNT).toInt() != 3
@@ -528,61 +525,35 @@ bool AddKitOperation::test() const
}
#endif
QVariantMap AddKitOperation::addKit(const QVariantMap &map,
const QString &id, const QString &displayName,
const QString &icon, const QString &debuggerId,
const quint32 &debuggerType, const QString &debugger,
const QString &deviceType, const QString &device,
const QString &sysRoot, const QHash<QString, QString> &tcs, const QString &qt,
const QString &mkspec, const QString &cmakeId,
const QString &cmakeGenerator, const QString &cmakeExtraGenerator,
const QString &cmakeGeneratorToolset,
const QString &cmakeGeneratorPlatform,
const QStringList &cmakeConfiguration, const QStringList &env,
const KeyValuePairList &extra)
QVariantMap AddKitData::addKit(const QVariantMap &map) const
{
QVariantMap tcMap = load("ToolChains");
QVariantMap qtMap = load("QtVersions");
QVariantMap devMap = load("Devices");
QVariantMap cmakeMap = load("cmaketools");
QVariantMap tcMap = Operation::load("ToolChains");
QVariantMap qtMap = Operation::load("QtVersions");
QVariantMap devMap = Operation::load("Devices");
QVariantMap cmakeMap = Operation::load("cmaketools");
return addKit(map, tcMap, qtMap, devMap, cmakeMap, id, displayName, icon, debuggerId, debuggerType,
debugger, deviceType, device, sysRoot, tcs, qt, mkspec,
cmakeId, cmakeGenerator, cmakeExtraGenerator, cmakeGeneratorToolset,
cmakeGeneratorPlatform, cmakeConfiguration,
env, extra);
return AddKitData::addKit(map, tcMap, qtMap, devMap, cmakeMap);
}
QVariantMap AddKitOperation::addKit(const QVariantMap &map, const QVariantMap &tcMap,
QVariantMap AddKitData::addKit(const QVariantMap &map, const QVariantMap &tcMap,
const QVariantMap &qtMap, const QVariantMap &devMap,
const QVariantMap &cmakeMap,
const QString &id, const QString &displayName,
const QString &icon, const QString &debuggerId,
const quint32 &debuggerType, const QString &debugger,
const QString &deviceType, const QString &device,
const QString &sysRoot, const QHash<QString, QString> &tcs, const QString &qt,
const QString &mkspec, const QString &cmakeId,
const QString &cmakeGenerator, const QString &cmakeExtraGenerator,
const QString &cmakeGeneratorToolset,
const QString &cmakeGeneratorPlatform,
const QStringList &cmakeConfiguration, const QStringList &env,
const KeyValuePairList &extra)
const QVariantMap &cmakeMap) const
{
// Sanity check: Make sure autodetection source is not in use already:
QStringList valueKeys = FindValueOperation::findValue(map, QVariant(id));
const QStringList valueKeys = FindValueOperation::findValue(map, QVariant(m_id));
bool hasId = false;
foreach (const QString &k, valueKeys) {
for (const QString &k : valueKeys) {
if (k.endsWith(QString('/') + ID)) {
hasId = true;
break;
}
}
if (hasId) {
std::cerr << "Error: Id " << qPrintable(id) << " already defined as kit." << std::endl;
std::cerr << "Error: Id " << qPrintable(m_id) << " already defined as kit." << std::endl;
return QVariantMap();
}
for (auto i = tcs.constBegin(); i != tcs.constEnd(); ++i) {
for (auto i = m_tcs.constBegin(); i != m_tcs.constEnd(); ++i) {
if (!i.value().isEmpty() && !AddToolChainOperation::exists(tcMap, i.value())) {
const QRegularExpression abiRegExp("^[a-z0-9_]+-[a-z0-9_]+-[a-z0-9_]+-[a-z0-9_]+-(8|16|32|64|128)bit$");
if (!abiRegExp.match(i.value()).hasMatch()) {
@@ -593,15 +564,15 @@ QVariantMap AddKitOperation::addKit(const QVariantMap &map, const QVariantMap &t
}
}
QString qtId = qt;
QString qtId = m_qt;
if (!qtId.isEmpty() && !qtId.startsWith("SDK."))
qtId = QString::fromLatin1("SDK.") + qt;
if (!qtId.isEmpty() && !AddQtOperation::exists(qtMap, qtId)) {
qtId = QString::fromLatin1("SDK.") + m_qt;
if (!qtId.isEmpty() && !AddQtData::exists(qtMap, qtId)) {
std::cerr << "Error: Qt " << qPrintable(qtId) << " does not exist." << std::endl;
return QVariantMap();
}
if (!device.isEmpty() && !AddDeviceOperation::exists(devMap, device)) {
std::cerr << "Error: Device " << qPrintable(device) << " does not exist." << std::endl;
if (!m_device.isEmpty() && !AddDeviceOperation::exists(devMap, m_device)) {
std::cerr << "Error: Device " << qPrintable(m_device) << " does not exist." << std::endl;
return QVariantMap();
}
@@ -609,8 +580,8 @@ QVariantMap AddKitOperation::addKit(const QVariantMap &map, const QVariantMap &t
if (!qtId.isNull() && qtId.isEmpty())
qtId = "-1";
if (!cmakeId.isEmpty() && !AddCMakeOperation::exists(cmakeMap, cmakeId)) {
std::cerr << "Error: CMake tool " << qPrintable(cmakeId) << " does not exist." << std::endl;
if (!m_cmakeId.isEmpty() && !AddCMakeData::exists(cmakeMap, m_cmakeId)) {
std::cerr << "Error: CMake tool " << qPrintable(m_cmakeId) << " does not exist." << std::endl;
return QVariantMap();
}
@@ -625,68 +596,69 @@ QVariantMap AddKitOperation::addKit(const QVariantMap &map, const QVariantMap &t
QString defaultKit = GetOperation::get(map, DEFAULT).toString();
if (defaultKit.isEmpty())
defaultKit = id;
defaultKit = m_id;
// remove data:
QVariantMap cleaned = RmKeysOperation::rmKeys(map, {COUNT, DEFAULT});
// insert data:
KeyValuePairList data = {KeyValuePair({kit, ID}, QVariant(id)),
KeyValuePair({kit, DISPLAYNAME}, QVariant(displayName)),
KeyValuePair({kit, ICON}, QVariant(icon)),
KeyValuePairList data = {KeyValuePair({kit, ID}, QVariant(m_id)),
KeyValuePair({kit, DISPLAYNAME}, QVariant(m_displayName)),
KeyValuePair({kit, ICON}, QVariant(m_icon)),
KeyValuePair({kit, AUTODETECTED}, QVariant(true)),
KeyValuePair({kit, SDK}, QVariant(true))};
if (!debuggerId.isEmpty() || !debugger.isEmpty()) {
if (debuggerId.isEmpty()) {
data << KeyValuePair({kit, DATA, DEBUGGER, DEBUGGER_ENGINE}, QVariant(debuggerType));
data << KeyValuePair({kit, DATA, DEBUGGER, DEBUGGER_BINARY}, QVariant(debugger));
if (!m_debuggerId.isEmpty() || !m_debugger.isEmpty()) {
if (m_debuggerId.isEmpty()) {
data << KeyValuePair({kit, DATA, DEBUGGER, DEBUGGER_ENGINE}, QVariant(m_debuggerEngine));
data << KeyValuePair({kit, DATA, DEBUGGER, DEBUGGER_BINARY}, QVariant(m_debugger));
} else {
data << KeyValuePair({kit, DATA, DEBUGGER }, QVariant(debuggerId));
data << KeyValuePair({kit, DATA, DEBUGGER }, QVariant(m_debuggerId));
}
}
if (!deviceType.isNull())
data << KeyValuePair({kit, DATA, DEVICE_TYPE}, QVariant(deviceType));
if (!device.isNull())
data << KeyValuePair({kit, DATA, DEVICE_ID}, QVariant(device));
if (!sysRoot.isNull())
data << KeyValuePair({kit, DATA, SYSROOT}, Utils::FilePath::fromUserInput(sysRoot).toVariant());
for (auto i = tcs.constBegin(); i != tcs.constEnd(); ++i)
if (!m_deviceType.isNull())
data << KeyValuePair({kit, DATA, DEVICE_TYPE}, QVariant(m_deviceType));
if (!m_device.isNull())
data << KeyValuePair({kit, DATA, DEVICE_ID}, QVariant(m_device));
if (!m_sysRoot.isNull())
data << KeyValuePair({kit, DATA, SYSROOT}, Utils::FilePath::fromUserInput(m_sysRoot).toVariant());
for (auto i = m_tcs.constBegin(); i != m_tcs.constEnd(); ++i)
data << KeyValuePair({kit, DATA, TOOLCHAIN, i.key()}, QVariant(i.value()));
if (!qtId.isNull())
data << KeyValuePair({kit, DATA, QT}, QVariant(qtId));
if (!mkspec.isNull())
data << KeyValuePair({kit, DATA, MKSPEC}, QVariant(mkspec));
if (!cmakeId.isNull())
data << KeyValuePair({kit, DATA, CMAKE_ID}, QVariant(cmakeId));
if (!cmakeGenerator.isNull()) {
if (!m_mkspec.isNull())
data << KeyValuePair({kit, DATA, MKSPEC}, QVariant(m_mkspec));
if (!m_cmakeId.isNull())
data << KeyValuePair({kit, DATA, CMAKE_ID}, QVariant(m_cmakeId));
if (!m_cmakeGenerator.isNull()) {
QVariantMap generatorMap;
generatorMap.insert("Generator", cmakeGenerator);
if (!cmakeExtraGenerator.isNull())
generatorMap.insert("ExtraGenerator", cmakeExtraGenerator);
if (!cmakeGeneratorToolset.isNull())
generatorMap.insert("Toolset", cmakeGeneratorToolset);
if (!cmakeGeneratorPlatform.isNull())
generatorMap.insert("Platform", cmakeGeneratorPlatform);
generatorMap.insert("Generator", m_cmakeGenerator);
if (!m_cmakeExtraGenerator.isNull())
generatorMap.insert("ExtraGenerator", m_cmakeExtraGenerator);
if (!m_cmakeGeneratorToolset.isNull())
generatorMap.insert("Toolset", m_cmakeGeneratorToolset);
if (!m_cmakeGeneratorPlatform.isNull())
generatorMap.insert("Platform", m_cmakeGeneratorPlatform);
data << KeyValuePair({kit, DATA, CMAKE_GENERATOR}, generatorMap);
}
if (!cmakeConfiguration.isEmpty())
data << KeyValuePair({kit, DATA, CMAKE_CONFIGURATION}, QVariant(cmakeConfiguration));
if (!env.isEmpty())
data << KeyValuePair({kit, DATA, ENV}, QVariant(env));
if (!m_cmakeConfiguration.isEmpty())
data << KeyValuePair({kit, DATA, CMAKE_CONFIGURATION}, QVariant(m_cmakeConfiguration));
if (!m_env.isEmpty())
data << KeyValuePair({kit, DATA, ENV}, QVariant(m_env));
data << KeyValuePair(DEFAULT, QVariant(defaultKit));
data << KeyValuePair(COUNT, QVariant(count + 1));
KeyValuePairList qtExtraList;
foreach (const KeyValuePair &pair, extra)
foreach (const KeyValuePair &pair, m_extra)
qtExtraList << KeyValuePair(QStringList() << kit << pair.key, pair.value);
data.append(qtExtraList);
return AddKeysOperation::addKeys(cleaned, data);
return AddKeysData{data}.addKeys(cleaned);
}
QVariantMap AddKitOperation::initializeKits()
QVariantMap AddKitData::initializeKits()
{
QVariantMap map;
map.insert(VERSION, 1);

57
src/tools/sdktool/addkitoperation.h
View File

@@ -28,49 +28,17 @@
#include "operation.h"
#include <QHash>
#include <QString>
class AddKitOperation : public Operation
class AddKitData
{
public:
QString name() const;
QString helpText() const;
QString argumentsHelpText() const;
bool setArguments(const QStringList &args);
int execute() const;
#ifdef WITH_TESTS
bool test() const;
#endif
static QVariantMap addKit(const QVariantMap &map, const QString &id, const QString &displayName,
const QString &icon, const QString &debuggerId,
const quint32 &debuggerType, const QString &debugger,
const QString &deviceType, const QString &device,
const QString &sysRoot, const QHash<QString, QString> &tcs,
const QString &qt, const QString &mkspec,
const QString &cmakeId, const QString &cmakeGenerator,
const QString &cmakeExtraGenerator, const QString &cmakeGeneratorToolset,
const QString &cmakeGeneratorPlatform,
const QStringList &cmakeConfiguration, const QStringList &env,
const KeyValuePairList &extra);
QVariantMap addKit(const QVariantMap &map) const;
QVariantMap addKit(const QVariantMap &map, const QVariantMap &tcMap,
const QVariantMap &qtMap, const QVariantMap &devMap,
const QVariantMap &cmakeMap) const;
static QVariantMap initializeKits();
// internal:
static QVariantMap addKit(const QVariantMap &map, const QVariantMap &tcMap,
const QVariantMap &qtMap, const QVariantMap &devMap, const QVariantMap &cmakeMap,
const QString &id, const QString &displayName,
const QString &icon, const QString &debuggerId,
const quint32 &debuggerType, const QString &debugger,
const QString &deviceType, const QString &device,
const QString &sysRoot, const QHash<QString, QString> &tcs,
const QString &qt, const QString &mkspec, const QString &cmakeId, const QString &cmakeGenerator, const QString &cmakeExtraGenerator, const QString &cmakeGeneratorToolset, const QString &cmakeGeneratorPlatform, const QStringList &cmakeConfiguration, const QStringList &env,
const KeyValuePairList &extra);
private:
QString m_id;
QString m_displayName;
QString m_icon;
@@ -92,3 +60,18 @@ private:
QStringList m_env;
KeyValuePairList m_extra;
};
class AddKitOperation : public Operation, public AddKitData
{
public:
QString name() const final;
QString helpText() const final;
QString argumentsHelpText() const final;
bool setArguments(const QStringList &args) final;
int execute() const final;
#ifdef WITH_TESTS
bool test() const final;
#endif
};

60
src/tools/sdktool/addqtoperation.cpp
View File

@@ -169,7 +169,7 @@ int AddQtOperation::execute() const
if (map.isEmpty())
map = initializeQtVersions();
QVariantMap result = addQt(map, m_id, m_displayName, m_type, m_qmake, m_extra, m_abis);
QVariantMap result = addQt(map);
if (result.isEmpty() || result == map)
return 2;
@@ -180,6 +180,7 @@ int AddQtOperation::execute() const
#ifdef WITH_TESTS
bool AddQtOperation::test() const
{
AddQtData qtData;
QVariantMap map = initializeQtVersions();
if (map.count() != 1
@@ -188,16 +189,13 @@ bool AddQtOperation::test() const
return false;
#if defined Q_OS_WIN
map = addQt(map, QLatin1String("{some-qt-id}"), QLatin1String("Test Qt Version"), QLatin1String("testType"),
QLatin1String("/tmp//../tmp/test\\qmake"),
KeyValuePairList() << KeyValuePair(QLatin1String("extraData"), QVariant(QLatin1String("extraValue"))),
QStringList());
qtData = {"{some-qt-id}", "Test Qt Version", "testType", "/tmp//../tmp/test\\qmake", {},
{{QLatin1String("extraData"), QVariant(QLatin1String("extraValue"))}}};
#else
map = addQt(map, QLatin1String("{some-qt-id}"), QLatin1String("Test Qt Version"), QLatin1String("testType"),
QLatin1String("/tmp//../tmp/test/qmake"),
KeyValuePairList() << KeyValuePair(QLatin1String("extraData"), QVariant(QLatin1String("extraValue"))),
QStringList());
qtData = {"{some-qt-id}", "Test Qt Version", "testType", "/tmp//../tmp/test/qmake", {},
{{QLatin1String("extraData"), QVariant(QLatin1String("extraValue"))}}};
#endif
map = qtData.addQt(map);
if (map.count() != 2
|| !map.contains(QLatin1String(VERSION))
@@ -226,18 +224,16 @@ bool AddQtOperation::test() const
return false;
// Ignore existing ids:
QVariantMap result = addQt(map, QLatin1String("{some-qt-id}"), QLatin1String("Test Qt Version2"), QLatin1String("testType2"),
QLatin1String("/tmp/test/qmake2"),
KeyValuePairList() << KeyValuePair(QLatin1String("extraData"), QVariant(QLatin1String("extraValue"))),
QStringList());
qtData = {"{some-qt-id}", "Test Qt Version2", "testType2", "/tmp/test/qmake2", {},
{{QLatin1String("extraData"), QVariant(QLatin1String("extraValue"))}}};
QVariantMap result = qtData.addQt(map);
if (!result.isEmpty())
return false;
// add 2nd Qt version:
map = addQt(map, QLatin1String("testId2"), QLatin1String("Test Qt Version"), QLatin1String("testType3"),
QLatin1String("/tmp/test/qmake2"),
KeyValuePairList() << KeyValuePair(QLatin1String("extraData"), QVariant(QLatin1String("extraValue"))),
QStringList());
qtData = {"testId2", "Test Qt Version", "testType3", "/tmp/test/qmake2", {},
{{QLatin1String("extraData"), QVariant(QLatin1String("extraValue"))}}};
map = qtData.addQt(map);
if (map.count() != 3
|| !map.contains(QLatin1String(VERSION))
|| map.value(QLatin1String(VERSION)).toInt() != 1
@@ -272,16 +268,13 @@ bool AddQtOperation::test() const
}
#endif
QVariantMap AddQtOperation::addQt(const QVariantMap &map,
const QString &id, const QString &displayName, const QString &type,
const QString &qmake, const KeyValuePairList &extra,
const QStringList &abis)
QVariantMap AddQtData::addQt(const QVariantMap &map) const
{
QString sdkId = extendId(id);
QString sdkId = extendId(m_id);
// Sanity check: Make sure autodetection source is not in use already:
if (exists(map, sdkId)) {
std::cerr << "Error: Id " << qPrintable(id) << " already defined as Qt versions." << std::endl;
std::cerr << "Error: Id " << qPrintable(m_id) << " already defined as Qt versions." << std::endl;
return QVariantMap();
}
@@ -299,40 +292,41 @@ QVariantMap AddQtOperation::addQt(const QVariantMap &map,
const QString qt = QString::fromLatin1(PREFIX) + QString::number(versionCount);
// Sanitize qmake path:
FilePath saneQmake = FilePath::fromUserInput(qmake).cleanPath();
FilePath saneQmake = FilePath::fromUserInput(m_qmake).cleanPath();
// insert data:
KeyValuePairList data;
data << KeyValuePair(QStringList() << qt << QLatin1String(ID), QVariant(-1));
data << KeyValuePair(QStringList() << qt << QLatin1String(DISPLAYNAME), QVariant(displayName));
data << KeyValuePair(QStringList() << qt << QLatin1String(DISPLAYNAME), QVariant(m_displayName));
data << KeyValuePair(QStringList() << qt << QLatin1String(AUTODETECTED), QVariant(true));
data << KeyValuePair(QStringList() << qt << QLatin1String(AUTODETECTION_SOURCE), QVariant(sdkId));
data << KeyValuePair(QStringList() << qt << QLatin1String(QMAKE), saneQmake.toVariant());
data << KeyValuePair(QStringList() << qt << QLatin1String(TYPE), QVariant(type));
data << KeyValuePair(QStringList() << qt << ABIS, QVariant(abis));
data << KeyValuePair(QStringList() << qt << QLatin1String(TYPE), QVariant(m_type));
data << KeyValuePair(QStringList() << qt << ABIS, QVariant(m_abis));
KeyValuePairList qtExtraList;
foreach (const KeyValuePair &pair, extra)
foreach (const KeyValuePair &pair, m_extra)
qtExtraList << KeyValuePair(QStringList() << qt << pair.key, pair.value);
data.append(qtExtraList);
return AddKeysOperation::addKeys(map, data);
return AddKeysData{data}.addKeys(map);
}
QVariantMap AddQtOperation::initializeQtVersions()
QVariantMap AddQtData::initializeQtVersions()
{
QVariantMap map;
map.insert(QLatin1String(VERSION), 1);
return map;
}
bool AddQtOperation::exists(const QString &id)
bool AddQtData::exists(const QString &id)
{
QVariantMap map = load(QLatin1String("QtVersions"));
QVariantMap map = Operation::load(QLatin1String("QtVersions"));
return exists(map, id);
}
bool AddQtOperation::exists(const QVariantMap &map, const QString &id)
bool AddQtData::exists(const QVariantMap &map, const QString &id)
{
QString sdkId = extendId(id);

36
src/tools/sdktool/addqtoperation.h
View File

@@ -27,34 +27,16 @@
#include "operation.h"
#include <QString>
class AddQtOperation : public Operation
class AddQtData
{
public:
QString name() const;
QString helpText() const;
QString argumentsHelpText() const;
bool setArguments(const QStringList &args);
int execute() const;
#ifdef WITH_TESTS
bool test() const;
#endif
static QVariantMap addQt(const QVariantMap &map,
const QString &id, const QString &displayName, const QString &type,
const QString &qmake, const KeyValuePairList &extra,
const QStringList &abis);
QVariantMap addQt(const QVariantMap &map) const;
static QVariantMap initializeQtVersions();
static bool exists(const QString &id);
static bool exists(const QVariantMap &map, const QString &id);
private:
QString m_id; // actually this is the autodetectionSource
QString m_displayName;
QString m_type;
@@ -62,3 +44,17 @@ private:
QStringList m_abis;
KeyValuePairList m_extra;
};
class AddQtOperation : public Operation, public AddQtData
{
private:
QString name() const final;
QString helpText() const final;
QString argumentsHelpText() const final;
bool setArguments(const QStringList &args) final;
int execute() const final;
#ifdef WITH_TESTS
bool test() const final;
#endif
};

55
src/tools/sdktool/addtoolchainoperation.cpp
View File

@@ -158,8 +158,7 @@ int AddToolChainOperation::execute() const
if (map.isEmpty())
map = initializeToolChains();
QVariantMap result = addToolChain(map, m_id, m_languageId, m_displayName, m_path,
m_targetAbi, m_supportedAbis, m_extra);
QVariantMap result = addToolChain(map);
if (result.isEmpty() || map == result)
return 2;
@@ -172,8 +171,8 @@ bool AddToolChainOperation::test() const
QVariantMap map = initializeToolChains();
// Add toolchain:
map = addToolChain(map, "testId", "langId", "name", "/tmp/test", "test-abi", "test-abi,test-abi2",
KeyValuePairList() << KeyValuePair("ExtraKey", QVariant("ExtraValue")));
map = AddToolChainData{"testId", "langId", "name", "/tmp/test", "test-abi", "test-abi,test-abi2",
{{"ExtraKey", QVariant("ExtraValue")}}}.addToolChain(map);
if (map.value(COUNT).toInt() != 1
|| !map.contains(QString::fromLatin1(PREFIX) + '0'))
return false;
@@ -190,15 +189,15 @@ bool AddToolChainOperation::test() const
return false;
// Ignore same Id:
QVariantMap unchanged = addToolChain(map, "testId", "langId", "name2", "/tmp/test2", "test-abi2",
QVariantMap unchanged = AddToolChainData{"testId", "langId", "name2", "/tmp/test2", "test-abi2",
"test-abi2,test-abi3",
KeyValuePairList() << KeyValuePair("ExtraKey", QVariant("ExtraValue2")));
{{"ExtraKey", QVariant("ExtraValue2")}}}.addToolChain(map);
if (!unchanged.isEmpty())
return false;
// add 2nd tool chain:
map = addToolChain(map, "{some-tc-id}", "langId2", "name", "/tmp/test", "test-abi", "test-abi,test-abi2",
KeyValuePairList() << KeyValuePair("ExtraKey", QVariant("ExtraValue")));
map = AddToolChainData{"{some-tc-id}", "langId2", "name", "/tmp/test", "test-abi", "test-abi,test-abi2",
{{"ExtraKey", QVariant("ExtraValue")}}}.addToolChain(map);
if (map.value(COUNT).toInt() != 2
|| !map.contains(QString::fromLatin1(PREFIX) + '0')
|| !map.contains(QString::fromLatin1(PREFIX) + '1'))
@@ -230,15 +229,11 @@ bool AddToolChainOperation::test() const
}
#endif
QVariantMap AddToolChainOperation::addToolChain(const QVariantMap &map, const QString &id,
const QString &lang, const QString &displayName,
const QString &path, const QString &abi,
const QString &supportedAbis,
const KeyValuePairList &extra)
QVariantMap AddToolChainData::addToolChain(const QVariantMap &map) const
{
// Sanity check: Does the Id already exist?
if (exists(map, id)) {
std::cerr << "Error: Id " << qPrintable(id) << " already defined for tool chains." << std::endl;
if (exists(map, m_id)) {
std::cerr << "Error: Id " << qPrintable(m_id) << " already defined for tool chains." << std::endl;
return QVariantMap();
}
@@ -255,44 +250,44 @@ QVariantMap AddToolChainOperation::addToolChain(const QVariantMap &map, const QS
const QString tc = QString::fromLatin1(PREFIX) + QString::number(count);
KeyValuePairList data;
data << KeyValuePair({tc, ID}, QVariant(id));
data << KeyValuePair({tc, ID}, QVariant(m_id));
// Language compatibility hack for old Qt components that use the language spec from 4.2.
// Some Qt 5.15 components were actually still using this.
QString newLang; // QtC 4.3 and later
lang.toInt(&ok);
if (lang == "2" || lang == "Cxx") {
m_languageId.toInt(&ok);
if (m_languageId == "2" || m_languageId == "Cxx") {
newLang = "Cxx";
} else if (lang == "1" || lang == "C") {
} else if (m_languageId == "1" || m_languageId == "C") {
newLang = "C";
} else if (ok) {
std::cerr << "Error: Language ID must be 1 for C, 2 for Cxx "
<< "or a string like \"C\", \"Cxx\", \"Nim\" (was \""
<< qPrintable(lang) << "\")" << std::endl;
<< qPrintable(m_languageId) << "\")" << std::endl;
return {};
} else if (!ok) {
newLang = lang;
newLang = m_languageId;
}
data << KeyValuePair({tc, LANGUAGE_KEY_V2}, QVariant(newLang));
data << KeyValuePair({tc, DISPLAYNAME}, QVariant(displayName));
data << KeyValuePair({tc, DISPLAYNAME}, QVariant(m_displayName));
data << KeyValuePair({tc, AUTODETECTED}, QVariant(true));
data << KeyValuePair({tc, PATH}, Utils::FilePath::fromUserInput(path).toVariant());
data << KeyValuePair({tc, TARGET_ABI}, QVariant(abi));
data << KeyValuePair({tc, PATH}, Utils::FilePath::fromUserInput(m_path).toVariant());
data << KeyValuePair({tc, TARGET_ABI}, QVariant(m_targetAbi));
QVariantList abis;
QStringList abiStrings = supportedAbis.split(',');
QStringList abiStrings = m_supportedAbis.split(',');
foreach (const QString &s, abiStrings)
abis << QVariant(s);
data << KeyValuePair({tc, SUPPORTED_ABIS}, QVariant(abis));
KeyValuePairList tcExtraList;
foreach (const KeyValuePair &pair, extra)
foreach (const KeyValuePair &pair, m_extra)
tcExtraList << KeyValuePair(QStringList({tc}) << pair.key, pair.value);
data.append(tcExtraList);
data << KeyValuePair(COUNT, QVariant(count + 1));
return AddKeysOperation::addKeys(result, data);
return AddKeysData{data}.addKeys(result);
}
QVariantMap AddToolChainOperation::initializeToolChains()
QVariantMap AddToolChainData::initializeToolChains()
{
QVariantMap map;
map.insert(COUNT, 0);
@@ -300,7 +295,7 @@ QVariantMap AddToolChainOperation::initializeToolChains()
return map;
}
bool AddToolChainOperation::exists(const QVariantMap &map, const QString &id)
bool AddToolChainData::exists(const QVariantMap &map, const QString &id)
{
QStringList valueKeys = FindValueOperation::findValue(map, id);
// support old settings using QByteArray for id's
@@ -314,7 +309,7 @@ bool AddToolChainOperation::exists(const QVariantMap &map, const QString &id)
return false;
}
bool AddToolChainOperation::exists(const QString &id)
bool AddToolChainData::exists(const QString &id)
{
QVariantMap map = Operation::load("ToolChains");
return exists(map, id);

40
src/tools/sdktool/addtoolchainoperation.h
View File

@@ -27,34 +27,16 @@
#include "operation.h"
#include <QString>
class AddToolChainOperation : public Operation
class AddToolChainData
{
public:
QString name() const;
QString helpText() const;
QString argumentsHelpText() const;
bool setArguments(const QStringList &args);
int execute() const;
#ifdef WITH_TESTS
bool test() const;
#endif
static QVariantMap addToolChain(const QVariantMap &map,
const QString &id, const QString &lang,
const QString &displayName, const QString &path,
const QString &abi, const QString &supportedAbis,
const KeyValuePairList &extra);
QVariantMap addToolChain(const QVariantMap &map) const;
static QVariantMap initializeToolChains();
static bool exists(const QString &id);
static bool exists(const QVariantMap &map, const QString &id);
private:
QString m_id;
QString m_languageId;
QString m_displayName;
@@ -63,3 +45,19 @@ private:
QString m_supportedAbis;
KeyValuePairList m_extra;
};
class AddToolChainOperation : public Operation, public AddToolChainData
{
public:
QString name() const final;
QString helpText() const final;
QString argumentsHelpText() const final;
bool setArguments(const QStringList &args) final;
int execute() const final;
#ifdef WITH_TESTS
bool test() const final;
#endif
};

31
src/tools/sdktool/addvalueoperation.cpp
View File

@@ -79,7 +79,7 @@ bool AddValueOperation::setArguments(const QStringList &args)
m_file = tempArgs.takeFirst();
m_key = tempArgs.takeFirst();
for (const auto &arg : tempArgs) {
const auto val = Operation::valueFromString(arg);
const auto val = valueFromString(arg);
if (!val.isValid() || val.isNull()) {
std::cerr << "Error: " << std::quoted(arg.toStdString())
<< " is not a valid QVariant like string Type:Value.\n"
@@ -101,7 +101,7 @@ int AddValueOperation::execute() const
return FAILURE;
}
auto status = appendListToMap(map, m_key, m_values);
bool status = appendListToMap(map);
if (status) {
status = save(map, m_file);
@@ -122,13 +122,12 @@ bool AddValueOperation::test() const
testKvpList.append(KeyValuePair(QLatin1String("test/foobar"), QString::fromLatin1("int:42")));
testKvpList.append(KeyValuePair(QLatin1String("test/bar"), testDataList));
const auto valueList = QVariantList(
{Operation::valueFromString("QString:ELIL"), Operation::valueFromString("int:-1")});
const QVariantList valueList = {valueFromString("QString:ELIL"), valueFromString("int:-1")};
QVariantMap testMap;
// add to empty map
auto result = appendListToMap(testMap, "some key", valueList);
bool result = AddValueData{"some key", valueList}.appendListToMap(testMap);
if (result)
return false;
@@ -137,19 +136,19 @@ bool AddValueOperation::test() const
testMap.insert(QLatin1String("aKey"), "withAString");
// append to a value
result = appendListToMap(testMap, "aKey", valueList);
result = AddValueData{"aKey", valueList}.appendListToMap(testMap);
if (result)
return false;
testMap = AddKeysOperation::addKeys(testMap, testKvpList);
testMap = AddKeysData{testKvpList}.addKeys(testMap);
// quick sanity check
if (testMap.count() != 3 && testDataList.count() != 2 && testKvpList.count() != 3)
return false;
// successful adding of values
result = appendListToMap(testMap, "test/bar", valueList);
result = AddValueData{"test/bar", valueList}.appendListToMap(testMap);
if (!result)
return false;
@@ -165,30 +164,28 @@ bool AddValueOperation::test() const
}
#endif
bool AddValueOperation::appendListToMap(QVariantMap &map,
const QString &key,
const QVariantList &values)
bool AddValueData::appendListToMap(QVariantMap &map) const
{
const auto data = GetOperation::get(map, key);
const QVariant data = GetOperation::get(map, m_key);
if (!data.isValid() || data.isNull()) {
std::cerr << "Error: Could not retrieve value for key " << std::quoted(key.toStdString())
std::cerr << "Error: Could not retrieve value for key " << std::quoted(m_key.toStdString())
<< std::endl;
return false;
}
if (data.type() != QVariant::List) {
std::cerr << "Error: Data stored in " << std::quoted(key.toStdString())
std::cerr << "Error: Data stored in " << std::quoted(m_key.toStdString())
<< " is not a QVariantList." << std::endl;
return false;
}
auto newList = qvariant_cast<QVariantList>(data);
newList.append(values);
newList.append(m_values);
map = RmKeysOperation::rmKeys(map, {key});
map = AddKeysOperation::addKeys(map, {Operation::KeyValuePair(key, newList)});
map = RmKeysOperation::rmKeys(map, {m_key});
map = AddKeysData{{{m_key, newList}}}.addKeys(map);
return true;
}

37
src/tools/sdktool/addvalueoperation.h
View File

@@ -28,25 +28,30 @@
#include "operation.h"
class AddValueOperation : public Operation
class AddValueData
{
public:
QString name() const override;
QString helpText() const override;
QString argumentsHelpText() const override;
bool appendListToMap(QVariantMap &map) const;
bool setArguments(const QStringList &args) override;
int execute() const override;
#ifdef WITH_TESTS
bool test() const override;
#endif
static bool appendListToMap(QVariantMap &map, const QString &key, const QVariantList &values);
private:
QString m_file;
QString m_key;
QVariantList m_values;
};
class AddValueOperation : public Operation, public AddValueData
{
public:
QString name() const final;
QString helpText() const final;
QString argumentsHelpText() const final;
bool setArguments(const QStringList &args) final;
int execute() const final;
#ifdef WITH_TESTS
bool test() const final;
#endif
private:
QString m_file;
};

13
src/tools/sdktool/findkeyoperation.h
View File

@@ -30,18 +30,17 @@
class FindKeyOperation : public Operation
{
public:
QString name() const;
QString helpText() const;
QString argumentsHelpText() const;
QString name() const final;
QString helpText() const final;
QString argumentsHelpText() const final;
bool setArguments(const QStringList &args);
bool setArguments(const QStringList &args) final;
int execute() const;
int execute() const final;
#ifdef WITH_TESTS
bool test() const;
bool test() const final;
#endif
static QStringList findKey(const QVariant &in, const QString &key,
const QString &prefix = QString());

2
src/tools/sdktool/findvalueoperation.cpp
View File

@@ -53,7 +53,7 @@ bool FindValueOperation::setArguments(const QStringList &args)
continue;
}
QVariant v = Operation::valueFromString(current);
QVariant v = valueFromString(current);
if (!v.isValid()) {
std::cerr << "Value for key '" << qPrintable(current) << "' is not valid." << std::endl << std::endl;
return false;

12
src/tools/sdktool/findvalueoperation.h
View File

@@ -30,16 +30,16 @@
class FindValueOperation : public Operation
{
public:
QString name() const;
QString helpText() const;
QString argumentsHelpText() const;
QString name() const final;
QString helpText() const final;
QString argumentsHelpText() const final;
bool setArguments(const QStringList &args);
bool setArguments(const QStringList &args) final;
int execute() const;
int execute() const final;
#ifdef WITH_TESTS
bool test() const;
bool test() const final;
#endif
static QStringList findValue(const QVariant &in, const QVariant &value,

12
src/tools/sdktool/getoperation.h
View File

@@ -30,16 +30,16 @@
class GetOperation : public Operation
{
public:
QString name() const;
QString helpText() const;
QString argumentsHelpText() const;
QString name() const final;
QString helpText() const final;
QString argumentsHelpText() const final;
bool setArguments(const QStringList &args);
bool setArguments(const QStringList &args) final;
int execute() const;
int execute() const final;
#ifdef WITH_TESTS
bool test() const;
bool test() const final;
#endif
static QVariant get(const QVariantMap &map, const QString &key);

10
src/tools/sdktool/operation.cpp
View File

@@ -34,7 +34,7 @@
#include <iostream>
QVariant Operation::valueFromString(const QString &v)
QVariant valueFromString(const QString &v)
{
int pos = v.indexOf(QLatin1Char(':'));
if (pos <= 0)
@@ -62,23 +62,23 @@ QVariant Operation::valueFromString(const QString &v)
return QVariant();
}
Operation::KeyValuePair::KeyValuePair(const QString &k, const QString &v) :
KeyValuePair::KeyValuePair(const QString &k, const QString &v) :
value(valueFromString(v))
{
key = k.split(QLatin1Char('/'));
}
Operation::KeyValuePair::KeyValuePair(const QString &k, const QVariant &v) :
KeyValuePair::KeyValuePair(const QString &k, const QVariant &v) :
value(v)
{
key = k.split(QLatin1Char('/'));
}
Operation::KeyValuePair::KeyValuePair(const QStringList &k, const QString &v) :
KeyValuePair::KeyValuePair(const QStringList &k, const QString &v) :
key(k), value(valueFromString(v))
{ }
Operation::KeyValuePair::KeyValuePair(const QStringList &k, const QVariant &v) :
KeyValuePair::KeyValuePair(const QStringList &k, const QVariant &v) :
key(k), value(v)
{ }

30
src/tools/sdktool/operation.h
View File

@@ -30,21 +30,25 @@
#include <QStringList>
#include <QVariant>
class KeyValuePair
{
public:
KeyValuePair(const QString &k, const QString &v);
KeyValuePair(const QString &k, const QVariant &v);
KeyValuePair(const QStringList &k, const QString &v);
KeyValuePair(const QStringList &k, const QVariant &v);
QStringList key;
QVariant value;
};
using KeyValuePairList = QList<KeyValuePair>;
QVariant valueFromString(const QString &v);
class Operation
{
public:
class KeyValuePair {
public:
KeyValuePair(const QString &k, const QString &v);
KeyValuePair(const QString &k, const QVariant &v);
KeyValuePair(const QStringList &k, const QString &v);
KeyValuePair(const QStringList &k, const QVariant &v);
QStringList key;
QVariant value;
};
typedef QList<KeyValuePair> KeyValuePairList;
virtual ~Operation() { }
virtual QString name() const = 0;
@@ -61,6 +65,4 @@ public:
static QVariantMap load(const QString &file);
bool save(const QVariantMap &map, const QString &file) const;
static QVariant valueFromString(const QString &v);
};

22
src/tools/sdktool/rmcmakeoperation.cpp
View File

@@ -85,7 +85,7 @@ int RmCMakeOperation::execute() const
if (map.isEmpty())
return 0;
QVariantMap result = rmCMake(map, m_id);
QVariantMap result = RmCMakeData{m_id}.rmCMake(map);
if (result == map)
return 2;
@@ -98,20 +98,20 @@ bool RmCMakeOperation::test() const
// Add cmakes:
QVariantMap map = AddCMakeOperation::initializeCMake();
const QVariantMap emptyMap = map;
map = AddCMakeOperation::addCMake(map, "testId", "name", "/tmp/test",
KeyValuePairList({KeyValuePair("ExtraKey", QVariant("ExtraValue"))}));
map = AddCMakeOperation::addCMake(map, "testId2", "other name", "/tmp/test2", KeyValuePairList());
map = AddCMakeData{"testId", "name", "/tmp/test",
{{"ExtraKey", QVariant("ExtraValue")}}}.addCMake(map);
map = AddCMakeData{"testId2", "other name", "/tmp/test2", {}}.addCMake(map);
QVariantMap result = rmCMake(QVariantMap(), "nonexistent");
QVariantMap result = RmCMakeData{"nonexistent"}.rmCMake(QVariantMap());
if (!result.isEmpty())
return false;
result = rmCMake(map, "nonexistent");
result = RmCMakeData{"nonexistent"}.rmCMake(map);
if (result != map)
return false;
// Remove from map with both testId and testId2:
result = rmCMake(map, "testId2");
result = RmCMakeData{"testId2"}.rmCMake(map);
if (result == map
|| result.value(COUNT, 0).toInt() != 1
|| !result.contains(QString::fromLatin1(PREFIX) + "0")
@@ -119,7 +119,7 @@ bool RmCMakeOperation::test() const
return false;
// Remove from map with both testId and testId2:
result = rmCMake(map, "testId");
result = RmCMakeData{"testId"}.rmCMake(map);
if (result == map
|| result.value(COUNT, 0).toInt() != 1
|| !result.contains(QString::fromLatin1(PREFIX) + "0")
@@ -127,7 +127,7 @@ bool RmCMakeOperation::test() const
return false;
// Remove from map without testId!
result = rmCMake(result, "testId2");
result = RmCMakeData{"testId2"}.rmCMake(result);
if (result != emptyMap)
return false;
@@ -135,7 +135,7 @@ bool RmCMakeOperation::test() const
}
#endif
QVariantMap RmCMakeOperation::rmCMake(const QVariantMap &map, const QString &id)
QVariantMap RmCMakeData::rmCMake(const QVariantMap &map) const
{
// Find count of cmakes:
bool ok;
@@ -148,7 +148,7 @@ QVariantMap RmCMakeOperation::rmCMake(const QVariantMap &map, const QString &id)
QVariantList cmList;
for (int i = 0; i < count; ++i) {
QVariantMap cmData = GetOperation::get(map, QString::fromLatin1(PREFIX) + QString::number(i)).toMap();
if (cmData.value(ID).toString() != id)
if (cmData.value(ID).toString() != m_id)
cmList.append(cmData);
}

35
src/tools/sdktool/rmcmakeoperation.h
View File

@@ -27,25 +27,26 @@
#include "operation.h"
#include <QString>
class RmCMakeOperation : public Operation
class RmCMakeData
{
public:
QString name() const;
QString helpText() const;
QString argumentsHelpText() const;
QVariantMap rmCMake(const QVariantMap &map) const;
bool setArguments(const QStringList &args);
int execute() const;
#ifdef WITH_TESTS
bool test() const;
#endif
static QVariantMap rmCMake(const QVariantMap &map, const QString &id);
private:
QString m_id;
};
class RmCMakeOperation : public Operation, public RmCMakeData
{
public:
QString name() const final;
QString helpText() const final;
QString argumentsHelpText() const final;
bool setArguments(const QStringList &args) final;
int execute() const final;
#ifdef WITH_TESTS
bool test() const final;
#endif
};

21
src/tools/sdktool/rmdebuggeroperation.cpp
View File

@@ -95,16 +95,15 @@ bool RmDebuggerOperation::test() const
{
QVariantMap map =
AddDebuggerOperation::addDebugger(AddDebuggerOperation::initializeDebuggers(),
QLatin1String("id1"), QLatin1String("Name1"),
2, QLatin1String("/tmp/debugger1"),
QStringList() << QLatin1String("test11") << QLatin1String("test12"),
KeyValuePairList());
map =
AddDebuggerOperation::addDebugger(map, QLatin1String("id2"), QLatin1String("Name2"),
2, QLatin1String("/tmp/debugger2"),
QStringList() << QLatin1String("test21") << QLatin1String("test22"),
KeyValuePairList());
AddDebuggerData{QLatin1String("id1"), QLatin1String("Name1"),
2, QLatin1String("/tmp/debugger1"),
{"test11", "test12"}, {}}
.addDebugger(AddDebuggerOperation::initializeDebuggers());
map = AddDebuggerData{QLatin1String("id2"), QLatin1String("Name2"),
2, QLatin1String("/tmp/debugger2"),
{"test21", "test22"}, {}}
.addDebugger(map);
QVariantMap result = rmDebugger(map, QLatin1String("id2"));
if (result.count() != 3
@@ -178,6 +177,6 @@ QVariantMap RmDebuggerOperation::rmDebugger(const QVariantMap &map, const QStrin
debuggerList.at(i));
}
return AddKeysOperation::addKeys(result, data);
return AddKeysData{data}.addKeys(result);
}

54
src/tools/sdktool/rmkitoperation.cpp
View File

@@ -98,40 +98,40 @@ int RmKitOperation::execute() const
bool RmKitOperation::test() const
{
QVariantMap tcMap = AddToolChainOperation::initializeToolChains();
tcMap = AddToolChainOperation::addToolChain(tcMap, "{tc-id}", "langId", "TC", "/usr/bin/gcc",
"x86-linux-generic-elf-32bit",
"x86-linux-generic-elf-32bit",
KeyValuePairList());
tcMap = AddToolChainData{"{tc-id}", "langId", "TC", "/usr/bin/gcc",
"x86-linux-generic-elf-32bit", "x86-linux-generic-elf-32bit", {}}
.addToolChain(tcMap);
QVariantMap qtMap = AddQtOperation::initializeQtVersions();
qtMap = AddQtOperation::addQt(qtMap, "{qt-id}", "Qt", "desktop-qt", "/usr/bin/qmake",
KeyValuePairList(), QStringList());
QVariantMap qtMap = AddQtData::initializeQtVersions();
qtMap = AddQtData{"{qt-id}", "Qt", "desktop-qt", "/usr/bin/qmake", {}, {}}.addQt(qtMap);
QVariantMap devMap = AddDeviceOperation::initializeDevices();
devMap = AddDeviceOperation::addDevice(devMap, "{dev-id}", "Dev", 0, 0,
"HWplatform", "SWplatform",
"localhost", "10000-11000", "localhost", "", 42,
"desktop", "", 22, 10000, "uname", 1,
KeyValuePairList());
devMap = AddDeviceData{"{dev-id}", "Dev", 0, 0,
"HWplatform", "SWplatform",
"localhost", "10000-11000", "localhost", "", 42,
"desktop", "", 22, 10000, "uname", 1,
KeyValuePairList()}
.addDevice(devMap);
QHash<QString, QString> tcs;
tcs.insert("Cxx", "{tc-id}");
QVariantMap map =
AddKitOperation::addKit(AddKitOperation::initializeKits(), tcMap, qtMap, devMap,
QVariantMap(),
"testId", "Test Qt Version", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", QString(), QString(), tcs,
"{qt-id}", "unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(), QStringList(),
KeyValuePairList() << KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue")));
map =
AddKitOperation::addKit(map, tcMap, qtMap, devMap, QVariantMap(), "testId2", "Test Qt Version",
"/tmp/icon2.png", QString(), 1, "/usr/bin/gdb-test2",
"Desktop", QString(), QString(), tcs, "{qt-id}",
"unsupported/mkspec2",
QString(), QString(), QString(), QString(), QString(), QStringList(), QStringList(),
KeyValuePairList() << KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue2")));
AddKitData{"testId", "Test Qt Version", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", QString(), QString(), tcs,
"{qt-id}", "unsupported/mkspec",
QString(), QString(), QString(), QString(), QString(), QStringList(), QStringList(),
{{"PE.Profile.Data/extraData", QVariant("extraValue")}}}
.addKit(AddKitData::initializeKits(), tcMap, qtMap, devMap, {});
map = AddKitData{"testId2", "Test Qt Version",
"/tmp/icon2.png", QString(), 1, "/usr/bin/gdb-test2",
"Desktop", QString(), QString(), tcs, "{qt-id}",
"unsupported/mkspec2",
QString(), QString(), QString(), QString(), QString(), QStringList(), QStringList(),
{{"PE.Profile.Data/extraData", QVariant("extraValue2")}}}
.addKit(map, tcMap, qtMap, devMap, {});
QVariantMap result = rmKit(map, "testId");
if (result.count() != 4
@@ -212,5 +212,5 @@ QVariantMap RmKitOperation::rmKit(const QVariantMap &map, const QString &id)
data << KeyValuePair(QString::fromLatin1(PREFIX) + QString::number(i),
profileList.at(i));
return AddKeysOperation::addKeys(result, data);
return AddKeysData{data}.addKeys(result);
}

16
src/tools/sdktool/rmqtoperation.cpp
View File

@@ -95,19 +95,17 @@ int RmQtOperation::execute() const
bool RmQtOperation::test() const
{
// Add toolchain:
QVariantMap map = AddQtOperation::initializeQtVersions();
QVariantMap map = AddQtData::initializeQtVersions();
QVariantMap result = rmQt(QVariantMap(), QLatin1String("nonexistant"));
if (result != map)
return false;
map = AddQtOperation::addQt(map, QLatin1String("testId"), QLatin1String("name"), QLatin1String("type"),
QLatin1String("/tmp/test"),
KeyValuePairList() << KeyValuePair(QLatin1String("ExtraKey"), QVariant(QLatin1String("ExtraValue"))),
QStringList());
map = AddQtOperation::addQt(map, QLatin1String("testId2"), QLatin1String("other name"), QLatin1String("type"),
QLatin1String("/tmp/test2"),
KeyValuePairList(), QStringList());
map = AddQtData{"testId", "name", "type", "/tmp/test", {},
{{QLatin1String("ExtraKey"), QVariant(QLatin1String("ExtraValue"))}}}
.addQt(map);
map = AddQtData{"testId2", "other name", "type", "/tmp/test2", {}, {}}.addQt(map);
result = rmQt(map, QLatin1String("nonexistant"));
if (result != map)
@@ -149,7 +147,7 @@ QVariantMap RmQtOperation::rmQt(const QVariantMap &map, const QString &id)
qtList.append(qtData);
}
QVariantMap newMap = AddQtOperation::initializeQtVersions();
QVariantMap newMap = AddQtData::initializeQtVersions();
for (int i = 0; i < qtList.count(); ++i)
newMap.insert(QString::fromLatin1(PREFIX) + QString::number(i), qtList.at(i));

12
src/tools/sdktool/rmtoolchainoperation.cpp
View File

@@ -97,11 +97,13 @@ bool RmToolChainOperation::test() const
{
// Add toolchain:
QVariantMap map = AddToolChainOperation::initializeToolChains();
map = AddToolChainOperation::addToolChain(map, "testId", "langId", "name", "/tmp/test", "test-abi",
"test-abi,test-abi2",
KeyValuePairList({KeyValuePair("ExtraKey", QVariant("ExtraValue"))}));
map = AddToolChainOperation::addToolChain(map, "testId2", "langId", "other name", "/tmp/test2", "test-abi",
"test-abi,test-abi2", KeyValuePairList());
map = AddToolChainData{"testId", "langId", "name", "/tmp/test", "test-abi",
"test-abi,test-abi2", {{"ExtraKey", QVariant("ExtraValue")}}}
.addToolChain(map);
map = AddToolChainData{"testId2", "langId", "other name", "/tmp/test2", "test-abi",
"test-abi,test-abi2", {}}
.addToolChain(map);
QVariantMap result = rmToolChain(QVariantMap(), "nonexistent");
if (!result.isEmpty())

12
src/tools/sdktool/rmtoolchainoperation.h
View File

@@ -32,16 +32,16 @@
class RmToolChainOperation : public Operation
{
public:
QString name() const;
QString helpText() const;
QString argumentsHelpText() const;
QString name() const final;
QString helpText() const final;
QString argumentsHelpText() const final;
bool setArguments(const QStringList &args);
bool setArguments(const QStringList &args) final;
int execute() const;
int execute() const final;
#ifdef WITH_TESTS
bool test() const;
bool test() const final;
#endif
static QVariantMap rmToolChain(const QVariantMap &map, const QString &id);