|
|
#include "AmdaParser.h"
|
|
|
|
|
|
#include <DataSource/DataSourceItem.h>
|
|
|
|
|
|
#include <QFile>
|
|
|
#include <QJsonArray>
|
|
|
#include <QJsonDocument>
|
|
|
#include <QJsonObject>
|
|
|
|
|
|
Q_LOGGING_CATEGORY(LOG_AmdaParser, "AmdaParser")
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
// Significant keys of an AMDA's JSON file
|
|
|
const auto COMPONENT_KEY = QStringLiteral("component");
|
|
|
const auto PRODUCT_KEY = QStringLiteral("parameter");
|
|
|
const auto ROOT_KEY = QStringLiteral("dataCenter");
|
|
|
|
|
|
/// Returns the correct item type according to the key passed in parameter
|
|
|
DataSourceItemType itemType(const QString &key) noexcept
|
|
|
{
|
|
|
if (key == PRODUCT_KEY) {
|
|
|
return DataSourceItemType::PRODUCT;
|
|
|
}
|
|
|
else if (key == COMPONENT_KEY) {
|
|
|
return DataSourceItemType::COMPONENT;
|
|
|
}
|
|
|
else {
|
|
|
return DataSourceItemType::NODE;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Processes an entry of the JSON file to populate/create data source items
|
|
|
* @param jsonKey the entry's key
|
|
|
* @param jsonValue the entry's value
|
|
|
* @param item the current item for which the entry processing will be applied
|
|
|
* @param appendData flag indicating that the entry is part of an array. In the case of an array of
|
|
|
* values, each value will be concatenated to the others (rather than replacing the others)
|
|
|
*/
|
|
|
void parseEntry(const QString &jsonKey, const QJsonValue &jsonValue, DataSourceItem &item,
|
|
|
bool isArrayEntry = false)
|
|
|
{
|
|
|
if (jsonValue.isObject()) {
|
|
|
// Case of an object:
|
|
|
// - a new data source item is created and
|
|
|
// - parsing is called recursively to process the new item
|
|
|
// - the new item is then added as a child of the former item
|
|
|
auto object = jsonValue.toObject();
|
|
|
|
|
|
auto newItem = std::make_unique<DataSourceItem>(itemType(jsonKey));
|
|
|
|
|
|
for (auto it = object.constBegin(), end = object.constEnd(); it != end; ++it) {
|
|
|
parseEntry(it.key(), it.value(), *newItem);
|
|
|
}
|
|
|
|
|
|
item.appendChild(std::move(newItem));
|
|
|
}
|
|
|
else if (jsonValue.isArray()) {
|
|
|
// Case of an array: the item is populated with the arrays' content
|
|
|
auto object = jsonValue.toArray();
|
|
|
|
|
|
for (auto it = object.constBegin(), end = object.constEnd(); it != end; ++it) {
|
|
|
parseEntry(jsonKey, *it, item, true);
|
|
|
}
|
|
|
}
|
|
|
else {
|
|
|
// Case of a simple value: we add a data to the item. If the simple value is a part of an
|
|
|
// array, it is concatenated to the values already existing for this key
|
|
|
item.setData(jsonKey, jsonValue.toVariant(), isArrayEntry);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
} // namespace
|
|
|
|
|
|
std::unique_ptr<DataSourceItem> AmdaParser::readJson(const QString &filePath) noexcept
|
|
|
{
|
|
|
QFile jsonFile{filePath};
|
|
|
|
|
|
if (!jsonFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
|
qCCritical(LOG_AmdaParser())
|
|
|
<< QObject::tr("Can't retrieve data source tree from file %1: %2")
|
|
|
.arg(filePath, jsonFile.errorString());
|
|
|
return nullptr;
|
|
|
}
|
|
|
|
|
|
auto json = jsonFile.readAll();
|
|
|
auto jsonDocument = QJsonDocument::fromJson(json);
|
|
|
|
|
|
// Check preconditions for parsing
|
|
|
if (!jsonDocument.isObject()) {
|
|
|
qCCritical(LOG_AmdaParser())
|
|
|
<< QObject::tr(
|
|
|
"Can't retrieve data source tree from file %1: the file is malformed (there is "
|
|
|
"not one and only one root object)")
|
|
|
.arg(filePath);
|
|
|
return nullptr;
|
|
|
}
|
|
|
|
|
|
auto jsonDocumentObject = jsonDocument.object();
|
|
|
if (!jsonDocumentObject.contains(ROOT_KEY)) {
|
|
|
qCCritical(LOG_AmdaParser())
|
|
|
<< QObject::tr(
|
|
|
"Can't retrieve data source tree from file %1: the file is malformed (the key "
|
|
|
"for the root element was not found (%2))")
|
|
|
.arg(filePath, ROOT_KEY);
|
|
|
return nullptr;
|
|
|
}
|
|
|
|
|
|
auto rootValue = jsonDocumentObject.value(ROOT_KEY);
|
|
|
if (!rootValue.isObject()) {
|
|
|
qCCritical(LOG_AmdaParser())
|
|
|
<< QObject::tr(
|
|
|
"Can't retrieve data source tree from file %1: the file is malformed (the root "
|
|
|
"element is of the wrong type)")
|
|
|
.arg(filePath);
|
|
|
return nullptr;
|
|
|
}
|
|
|
|
|
|
// Makes the parsing
|
|
|
auto rootObject = rootValue.toObject();
|
|
|
auto rootItem = std::make_unique<DataSourceItem>(DataSourceItemType::NODE);
|
|
|
|
|
|
for (auto it = rootObject.constBegin(), end = rootObject.constEnd(); it != end; ++it) {
|
|
|
parseEntry(it.key(), it.value(), *rootItem);
|
|
|
}
|
|
|
|
|
|
return rootItem;
|
|
|
}
|
|
|
|
