mna_verification.cpp

Go to the documentation of this file.

//=============================================================================================================
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "mna_verification.h"
 
#include <QJsonArray>
#include <QCborArray>
#include <QSysInfo>
 
//=============================================================================================================
// USED NAMESPACES
//=============================================================================================================
 
using namespace MNALIB;
 
//=============================================================================================================
// MnaVerificationCheck
//=============================================================================================================
 
QJsonObject MnaVerificationCheck::toJson() const
{
    QJsonObject json;
    json[QStringLiteral("id")] = id;
    json[QStringLiteral("description")] = description;
    json[QStringLiteral("phase")] = phase;
    json[QStringLiteral("expression")] = expression;
    if (!script.code.isEmpty()) {
        json[QStringLiteral("script")] = script.toJson();
    }
    json[QStringLiteral("severity")] = severity;
    if (!onFail.isEmpty()) {
        json[QStringLiteral("on_fail")] = onFail;
    }
    return json;
}
 
//=============================================================================================================
 
MnaVerificationCheck MnaVerificationCheck::fromJson(const QJsonObject& json)
{
    MnaVerificationCheck c;
    c.id = json.value(QStringLiteral("id")).toString();
    c.description = json.value(QStringLiteral("description")).toString();
    c.phase = json.value(QStringLiteral("phase")).toString();
    c.expression = json.value(QStringLiteral("expression")).toString();
    if (json.contains(QStringLiteral("script"))) {
        c.script = MnaScript::fromJson(json.value(QStringLiteral("script")).toObject());
    }
    c.severity = json.value(QStringLiteral("severity")).toString();
    c.onFail = json.value(QStringLiteral("on_fail")).toString();
    return c;
}
 
//=============================================================================================================
 
QCborMap MnaVerificationCheck::toCbor() const
{
    QCborMap cbor;
    cbor.insert(QStringLiteral("id"), id);
    cbor.insert(QStringLiteral("description"), description);
    cbor.insert(QStringLiteral("phase"), phase);
    cbor.insert(QStringLiteral("expression"), expression);
    if (!script.code.isEmpty()) {
        cbor.insert(QStringLiteral("script"), script.toCbor());
    }
    cbor.insert(QStringLiteral("severity"), severity);
    if (!onFail.isEmpty()) {
        cbor.insert(QStringLiteral("on_fail"), onFail);
    }
    return cbor;
}
 
//=============================================================================================================
 
MnaVerificationCheck MnaVerificationCheck::fromCbor(const QCborMap& cbor)
{
    MnaVerificationCheck c;
    c.id = cbor.value(QStringLiteral("id")).toString();
    c.description = cbor.value(QStringLiteral("description")).toString();
    c.phase = cbor.value(QStringLiteral("phase")).toString();
    c.expression = cbor.value(QStringLiteral("expression")).toString();
    if (cbor.contains(QStringLiteral("script"))) {
        c.script = MnaScript::fromCbor(cbor.value(QStringLiteral("script")).toMap());
    }
    c.severity = cbor.value(QStringLiteral("severity")).toString();
    c.onFail = cbor.value(QStringLiteral("on_fail")).toString();
    return c;
}
 
//=============================================================================================================
// MnaVerificationResult
//=============================================================================================================
 
QJsonObject MnaVerificationResult::toJson() const
{
    QJsonObject json;
    json[QStringLiteral("check_id")] = checkId;
    json[QStringLiteral("passed")] = passed;
    json[QStringLiteral("severity")] = severity;
    json[QStringLiteral("message")] = message;
    json[QStringLiteral("actual_value")] = QJsonValue::fromVariant(actualValue);
    if (evaluatedAt.isValid()) {
        json[QStringLiteral("evaluated_at")] = evaluatedAt.toString(Qt::ISODateWithMs);
    }
    return json;
}
 
//=============================================================================================================
 
MnaVerificationResult MnaVerificationResult::fromJson(const QJsonObject& json)
{
    MnaVerificationResult r;
    r.checkId = json.value(QStringLiteral("check_id")).toString();
    r.passed = json.value(QStringLiteral("passed")).toBool(false);
    r.severity = json.value(QStringLiteral("severity")).toString();
    r.message = json.value(QStringLiteral("message")).toString();
    r.actualValue = json.value(QStringLiteral("actual_value")).toVariant();
    r.evaluatedAt = QDateTime::fromString(json.value(QStringLiteral("evaluated_at")).toString(), Qt::ISODateWithMs);
    return r;
}
 
//=============================================================================================================
 
QCborMap MnaVerificationResult::toCbor() const
{
    QCborMap cbor;
    cbor.insert(QStringLiteral("check_id"), checkId);
    cbor.insert(QStringLiteral("passed"), passed);
    cbor.insert(QStringLiteral("severity"), severity);
    cbor.insert(QStringLiteral("message"), message);
    cbor.insert(QStringLiteral("actual_value"), QCborValue::fromVariant(actualValue));
    if (evaluatedAt.isValid()) {
        cbor.insert(QStringLiteral("evaluated_at"), evaluatedAt.toString(Qt::ISODateWithMs));
    }
    return cbor;
}
 
//=============================================================================================================
 
MnaVerificationResult MnaVerificationResult::fromCbor(const QCborMap& cbor)
{
    MnaVerificationResult r;
    r.checkId = cbor.value(QStringLiteral("check_id")).toString();
    r.passed = cbor.value(QStringLiteral("passed")).toBool();
    r.severity = cbor.value(QStringLiteral("severity")).toString();
    r.message = cbor.value(QStringLiteral("message")).toString();
    r.actualValue = cbor.value(QStringLiteral("actual_value")).toVariant();
    r.evaluatedAt = QDateTime::fromString(cbor.value(QStringLiteral("evaluated_at")).toString(), Qt::ISODateWithMs);
    return r;
}
 
//=============================================================================================================
// MnaProvenance
//=============================================================================================================
 
QJsonObject MnaProvenance::toJson() const
{
    QJsonObject json;
 
    if (!inputHashes.isEmpty()) {
        QJsonObject hashObj;
        for (auto it = inputHashes.constBegin(); it != inputHashes.constEnd(); ++it) {
            hashObj.insert(it.key(), it.value());
        }
        json[QStringLiteral("input_hashes")] = hashObj;
    }
 
    if (!resolvedAttributes.isEmpty()) {
        QJsonObject attrObj;
        for (auto it = resolvedAttributes.constBegin(); it != resolvedAttributes.constEnd(); ++it) {
            attrObj.insert(it.key(), QJsonValue::fromVariant(it.value()));
        }
        json[QStringLiteral("resolved_attributes")] = attrObj;
    }
 
    if (!mneCppVersion.isEmpty())
        json[QStringLiteral("mne_cpp_version")] = mneCppVersion;
    if (!qtVersion.isEmpty())
        json[QStringLiteral("qt_version")] = qtVersion;
    if (!compilerInfo.isEmpty())
        json[QStringLiteral("compiler_info")] = compilerInfo;
    if (!osInfo.isEmpty())
        json[QStringLiteral("os_info")] = osInfo;
    if (!hostName.isEmpty())
        json[QStringLiteral("host_name")] = hostName;
    if (!externalToolVersion.isEmpty())
        json[QStringLiteral("external_tool_version")] = externalToolVersion;
 
    if (startedAt.isValid())
        json[QStringLiteral("started_at")] = startedAt.toString(Qt::ISODateWithMs);
    if (finishedAt.isValid())
        json[QStringLiteral("finished_at")] = finishedAt.toString(Qt::ISODateWithMs);
    if (wallTimeMs > 0)
        json[QStringLiteral("wall_time_ms")] = wallTimeMs;
    if (peakMemoryBytes > 0)
        json[QStringLiteral("peak_memory_bytes")] = peakMemoryBytes;
    if (randomSeed >= 0)
        json[QStringLiteral("random_seed")] = randomSeed;
 
    return json;
}
 
//=============================================================================================================
 
MnaProvenance MnaProvenance::fromJson(const QJsonObject& json)
{
    MnaProvenance p;
 
    const QJsonObject hashObj = json.value(QStringLiteral("input_hashes")).toObject();
    for (auto it = hashObj.constBegin(); it != hashObj.constEnd(); ++it) {
        p.inputHashes.insert(it.key(), it.value().toString());
    }
 
    const QJsonObject attrObj = json.value(QStringLiteral("resolved_attributes")).toObject();
    for (auto it = attrObj.constBegin(); it != attrObj.constEnd(); ++it) {
        p.resolvedAttributes.insert(it.key(), it.value().toVariant());
    }
 
    p.mneCppVersion = json.value(QStringLiteral("mne_cpp_version")).toString();
    p.qtVersion = json.value(QStringLiteral("qt_version")).toString();
    p.compilerInfo = json.value(QStringLiteral("compiler_info")).toString();
    p.osInfo = json.value(QStringLiteral("os_info")).toString();
    p.hostName = json.value(QStringLiteral("host_name")).toString();
    p.externalToolVersion = json.value(QStringLiteral("external_tool_version")).toString();
 
    p.startedAt = QDateTime::fromString(json.value(QStringLiteral("started_at")).toString(), Qt::ISODateWithMs);
    p.finishedAt = QDateTime::fromString(json.value(QStringLiteral("finished_at")).toString(), Qt::ISODateWithMs);
    p.wallTimeMs = static_cast<qint64>(json.value(QStringLiteral("wall_time_ms")).toDouble(0));
    p.peakMemoryBytes = static_cast<qint64>(json.value(QStringLiteral("peak_memory_bytes")).toDouble(0));
    p.randomSeed = static_cast<qint64>(json.value(QStringLiteral("random_seed")).toDouble(-1));
 
    return p;
}
 
//=============================================================================================================
 
QCborMap MnaProvenance::toCbor() const
{
    QCborMap cbor;
 
    if (!inputHashes.isEmpty()) {
        QCborMap hashMap;
        for (auto it = inputHashes.constBegin(); it != inputHashes.constEnd(); ++it) {
            hashMap.insert(it.key(), it.value());
        }
        cbor.insert(QStringLiteral("input_hashes"), hashMap);
    }
 
    if (!resolvedAttributes.isEmpty()) {
        QCborMap attrMap;
        for (auto it = resolvedAttributes.constBegin(); it != resolvedAttributes.constEnd(); ++it) {
            attrMap.insert(it.key(), QCborValue::fromVariant(it.value()));
        }
        cbor.insert(QStringLiteral("resolved_attributes"), attrMap);
    }
 
    if (!mneCppVersion.isEmpty())
        cbor.insert(QStringLiteral("mne_cpp_version"), mneCppVersion);
    if (!qtVersion.isEmpty())
        cbor.insert(QStringLiteral("qt_version"), qtVersion);
    if (!compilerInfo.isEmpty())
        cbor.insert(QStringLiteral("compiler_info"), compilerInfo);
    if (!osInfo.isEmpty())
        cbor.insert(QStringLiteral("os_info"), osInfo);
    if (!hostName.isEmpty())
        cbor.insert(QStringLiteral("host_name"), hostName);
    if (!externalToolVersion.isEmpty())
        cbor.insert(QStringLiteral("external_tool_version"), externalToolVersion);
 
    if (startedAt.isValid())
        cbor.insert(QStringLiteral("started_at"), startedAt.toString(Qt::ISODateWithMs));
    if (finishedAt.isValid())
        cbor.insert(QStringLiteral("finished_at"), finishedAt.toString(Qt::ISODateWithMs));
    if (wallTimeMs > 0)
        cbor.insert(QStringLiteral("wall_time_ms"), wallTimeMs);
    if (peakMemoryBytes > 0)
        cbor.insert(QStringLiteral("peak_memory_bytes"), peakMemoryBytes);
    if (randomSeed >= 0)
        cbor.insert(QStringLiteral("random_seed"), randomSeed);
 
    return cbor;
}
 
//=============================================================================================================
 
MnaProvenance MnaProvenance::fromCbor(const QCborMap& cbor)
{
    MnaProvenance p;
 
    const QCborMap hashMap = cbor.value(QStringLiteral("input_hashes")).toMap();
    for (auto it = hashMap.constBegin(); it != hashMap.constEnd(); ++it) {
        p.inputHashes.insert(it.key().toString(), it.value().toString());
    }
 
    const QCborMap attrMap = cbor.value(QStringLiteral("resolved_attributes")).toMap();
    for (auto it = attrMap.constBegin(); it != attrMap.constEnd(); ++it) {
        p.resolvedAttributes.insert(it.key().toString(), it.value().toVariant());
    }
 
    p.mneCppVersion = cbor.value(QStringLiteral("mne_cpp_version")).toString();
    p.qtVersion = cbor.value(QStringLiteral("qt_version")).toString();
    p.compilerInfo = cbor.value(QStringLiteral("compiler_info")).toString();
    p.osInfo = cbor.value(QStringLiteral("os_info")).toString();
    p.hostName = cbor.value(QStringLiteral("host_name")).toString();
    p.externalToolVersion = cbor.value(QStringLiteral("external_tool_version")).toString();
 
    p.startedAt = QDateTime::fromString(cbor.value(QStringLiteral("started_at")).toString(), Qt::ISODateWithMs);
    p.finishedAt = QDateTime::fromString(cbor.value(QStringLiteral("finished_at")).toString(), Qt::ISODateWithMs);
    p.wallTimeMs = cbor.value(QStringLiteral("wall_time_ms")).toInteger(0);
    p.peakMemoryBytes = cbor.value(QStringLiteral("peak_memory_bytes")).toInteger(0);
    p.randomSeed = cbor.value(QStringLiteral("random_seed")).toInteger(-1);
 
    return p;
}
 
//=============================================================================================================
// MnaVerification
//=============================================================================================================
 
QJsonObject MnaVerification::toJson() const
{
    QJsonObject json;
 
    if (!explanation.isEmpty()) {
        json[QStringLiteral("explanation")] = explanation;
    }
 
    if (!checks.isEmpty()) {
        QJsonArray arr;
        for (const MnaVerificationCheck& c : checks) {
            arr.append(c.toJson());
        }
        json[QStringLiteral("checks")] = arr;
    }
 
    if (!preResults.isEmpty()) {
        QJsonArray arr;
        for (const MnaVerificationResult& r : preResults) {
            arr.append(r.toJson());
        }
        json[QStringLiteral("pre_results")] = arr;
    }
 
    if (!postResults.isEmpty()) {
        QJsonArray arr;
        for (const MnaVerificationResult& r : postResults) {
            arr.append(r.toJson());
        }
        json[QStringLiteral("post_results")] = arr;
    }
 
    QJsonObject provObj = provenance.toJson();
    if (!provObj.isEmpty()) {
        json[QStringLiteral("provenance")] = provObj;
    }
 
    return json;
}
 
//=============================================================================================================
 
MnaVerification MnaVerification::fromJson(const QJsonObject& json)
{
    MnaVerification v;
 
    v.explanation = json.value(QStringLiteral("explanation")).toString();
 
    const QJsonArray checksArr = json.value(QStringLiteral("checks")).toArray();
    for (const QJsonValue& val : checksArr) {
        v.checks.append(MnaVerificationCheck::fromJson(val.toObject()));
    }
 
    const QJsonArray preArr = json.value(QStringLiteral("pre_results")).toArray();
    for (const QJsonValue& val : preArr) {
        v.preResults.append(MnaVerificationResult::fromJson(val.toObject()));
    }
 
    const QJsonArray postArr = json.value(QStringLiteral("post_results")).toArray();
    for (const QJsonValue& val : postArr) {
        v.postResults.append(MnaVerificationResult::fromJson(val.toObject()));
    }
 
    if (json.contains(QStringLiteral("provenance"))) {
        v.provenance = MnaProvenance::fromJson(json.value(QStringLiteral("provenance")).toObject());
    }
 
    return v;
}
 
//=============================================================================================================
 
QCborMap MnaVerification::toCbor() const
{
    QCborMap cbor;
 
    if (!explanation.isEmpty()) {
        cbor.insert(QStringLiteral("explanation"), explanation);
    }
 
    if (!checks.isEmpty()) {
        QCborArray arr;
        for (const MnaVerificationCheck& c : checks) {
            arr.append(c.toCbor());
        }
        cbor.insert(QStringLiteral("checks"), arr);
    }
 
    if (!preResults.isEmpty()) {
        QCborArray arr;
        for (const MnaVerificationResult& r : preResults) {
            arr.append(r.toCbor());
        }
        cbor.insert(QStringLiteral("pre_results"), arr);
    }
 
    if (!postResults.isEmpty()) {
        QCborArray arr;
        for (const MnaVerificationResult& r : postResults) {
            arr.append(r.toCbor());
        }
        cbor.insert(QStringLiteral("post_results"), arr);
    }
 
    QCborMap provMap = provenance.toCbor();
    if (!provMap.isEmpty()) {
        cbor.insert(QStringLiteral("provenance"), provMap);
    }
 
    return cbor;
}
 
//=============================================================================================================
 
MnaVerification MnaVerification::fromCbor(const QCborMap& cbor)
{
    MnaVerification v;
 
    v.explanation = cbor.value(QStringLiteral("explanation")).toString();
 
    const QCborArray checksArr = cbor.value(QStringLiteral("checks")).toArray();
    for (const QCborValue& val : checksArr) {
        v.checks.append(MnaVerificationCheck::fromCbor(val.toMap()));
    }
 
    const QCborArray preArr = cbor.value(QStringLiteral("pre_results")).toArray();
    for (const QCborValue& val : preArr) {
        v.preResults.append(MnaVerificationResult::fromCbor(val.toMap()));
    }
 
    const QCborArray postArr = cbor.value(QStringLiteral("post_results")).toArray();
    for (const QCborValue& val : postArr) {
        v.postResults.append(MnaVerificationResult::fromCbor(val.toMap()));
    }
 
    if (cbor.contains(QStringLiteral("provenance"))) {
        v.provenance = MnaProvenance::fromCbor(cbor.value(QStringLiteral("provenance")).toMap());
    }
 
    return v;
}