Create meta data from json support

src/FactSystem/FactMetaData.cc

@@ -15,9 +15,12 @@
 
 #include "FactMetaData.h"
 #include "QGroundControlQmlGlobal.h"
+#include "JsonHelper.h"
 
 #include <QDebug>
 #include <QtMath>
+#include <QJsonParseError>
+#include <QJsonArray>
 
 #include <limits>
 #include <cmath>
@@ -59,6 +62,16 @@ const FactMetaData::AppSettingsTranslation_s FactMetaData::_rgAppSettingsTransla
     { "m/s",    "kn",       true,   QGroundControlQmlGlobal::SpeedUnitsKnots,               FactMetaData::_metersPerSecondToKnots,              FactMetaData::_knotsToMetersPerSecond },
 };
 
+const char* FactMetaData::_decimalPlacesJsonKey =       "decimalPlaces";
+const char* FactMetaData::_nameJsonKey =                "name";
+const char* FactMetaData::_typeJsonKey =                "type";
+const char* FactMetaData::_shortDescriptionJsonKey =    "shortDescription";
+const char* FactMetaData::_longDescriptionJsonKey =     "longDescription";
+const char* FactMetaData::_unitsJsonKey =               "units";
+const char* FactMetaData::_defaultValueJsonKey =        "defaultValue";
+const char* FactMetaData::_minJsonKey =                 "min";
+const char* FactMetaData::_maxJsonKey =                 "max";
+
 FactMetaData::FactMetaData(QObject* parent)
     : QObject(parent)
     , _type(valueTypeInt32)
@@ -736,3 +749,120 @@ int FactMetaData::decimalPlaces(void) const
 
     return actualDecimalPlaces;
 }
+
+FactMetaData* FactMetaData::_createFromJsonObject(const QJsonObject& json, QObject* metaDataParent)
+{
+    QString         errorString;
+
+    // Make sure we have the required keys
+    QStringList requiredKeys;
+    requiredKeys << _nameJsonKey << _typeJsonKey;
+    if (!JsonHelper::validateRequiredKeys(json, requiredKeys, errorString)) {
+        qWarning() << errorString;
+        return new FactMetaData(valueTypeUint32, metaDataParent);
+    }
+
+    // Validate key types
+    QStringList             keys;
+    QList<QJsonValue::Type> types;
+    keys << _nameJsonKey << _decimalPlacesJsonKey << _typeJsonKey << _shortDescriptionJsonKey << _longDescriptionJsonKey << _unitsJsonKey << _defaultValueJsonKey << _minJsonKey << _maxJsonKey;
+    types << QJsonValue::String << QJsonValue::Double << QJsonValue::String << QJsonValue::String << QJsonValue::String << QJsonValue::String << QJsonValue::Double << QJsonValue::Double << QJsonValue::Double;
+    if (!JsonHelper::validateKeyTypes(json, keys, types, errorString)) {
+        qWarning() << errorString;
+        return new FactMetaData(valueTypeUint32, metaDataParent);
+    }
+
+    bool unknownType;
+    FactMetaData::ValueType_t type = FactMetaData::stringToType(json[_typeJsonKey].toString(), unknownType);
+    if (unknownType) {
+        qWarning() << "Unknown type" << json[_typeJsonKey].toString();
+        return new FactMetaData(valueTypeUint32, metaDataParent);
+    }
+
+    FactMetaData*   metaData = new FactMetaData(type, metaDataParent);
+
+    metaData->_name = json[_nameJsonKey].toString();
+
+    QStringList enumValues, enumStrings;
+    if (JsonHelper::parseEnum(json, enumStrings, enumValues, errorString)) {
+        for (int i=0; i<enumValues.count(); i++) {
+            QVariant    enumVariant;
+            QString     errorString;
+
+            if (metaData->convertAndValidateRaw(enumValues[i], false /* validate */, enumVariant, errorString)) {
+                metaData->addEnumInfo(enumStrings[i], enumVariant);
+            } else {
+                qWarning() << "Invalid enum value, name:" << metaData->name()
+                           << " type:" << metaData->type()
+                           << " value:" << enumValues[i]
+                           << " error:" << errorString;
+            }
+        }
+    } else {
+        qWarning() << errorString;
+    }
+
+    metaData->setDecimalPlaces(json[_decimalPlacesJsonKey].toInt(0));
+    metaData->setShortDescription(json[_shortDescriptionJsonKey].toString());
+    metaData->setLongDescription(json[_longDescriptionJsonKey].toString());
+
+    if (json.contains(_unitsJsonKey)) {
+        metaData->setRawUnits(json[_unitsJsonKey].toString());
+    }
+    if (json.contains(_defaultValueJsonKey)) {
+        metaData->setRawDefaultValue(json[_defaultValueJsonKey].toDouble());
+    }
+    if (json.contains(_minJsonKey)) {
+        metaData->setRawMin(json[_minJsonKey].toDouble());
+    }
+    if (json.contains(_maxJsonKey)) {
+        metaData->setRawMax(json[_maxJsonKey].toDouble());
+    }
+
+    return metaData;
+}
+
+QMap<QString, FactMetaData*> FactMetaData::createMapFromJsonFile(const QString& jsonFilename, QObject* metaDataParent)
+{
+    QMap<QString, FactMetaData*> metaDataMap;
+
+    QFile jsonFile(jsonFilename);
+    if (!jsonFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        qWarning() << "Unable to open file" << jsonFilename << jsonFile.errorString();
+        return metaDataMap;
+    }
+
+    QByteArray bytes = jsonFile.readAll();
+    jsonFile.close();
+    QJsonParseError jsonParseError;
+    QJsonDocument doc = QJsonDocument::fromJson(bytes, &jsonParseError);
+    if (jsonParseError.error != QJsonParseError::NoError) {
+        qWarning() <<  "Unable to parse json document" << jsonFilename << jsonParseError.errorString();
+        return metaDataMap;
+    }
+
+    if (!doc.isArray()) {
+        qWarning() << "json document is not array";
+        return metaDataMap;
+    }
+
+    QJsonArray jsonArray = doc.array();
+    for (int i=0; i<jsonArray.count(); i++) {
+        QJsonValueRef jsonValue = jsonArray[i];
+
+        if (!jsonValue.isObject()) {
+            qWarning() << QStringLiteral("JsonValue at index %1 not an object").arg(i);
+            continue;
+        }
+        QJsonObject jsonObject = jsonValue.toObject();
+        FactMetaData* metaData = _createFromJsonObject(jsonObject, metaDataParent);
+
+        if (metaDataMap.contains(metaData->name())) {
+            qWarning() << QStringLiteral("Duplicate fact name:") << metaData->name();
+        } else {
+            metaDataMap[metaData->name()] = metaData;
+        }
+    }
+
+    return metaDataMap;
+}

src/FactSystem/FactMetaData.h

@@ -17,7 +17,7 @@
 #include <QObject>
 #include <QString>
 #include <QVariant>
-
+#include <QJsonObject>
 
 /// Holds the meta data associated with a Fact.
 ///
@@ -46,6 +46,8 @@ public:
     FactMetaData(ValueType_t type, QObject* parent = NULL);
     FactMetaData(const FactMetaData& other, QObject* parent = NULL);
 
+    static QMap<QString, FactMetaData*> createMapFromJsonFile(const QString& jsonFilename, QObject* metaDataParent);
+
     const FactMetaData& operator=(const FactMetaData& other);
 
     /// Converts from meters to the user specified distance unit
@@ -142,6 +144,7 @@ private:
     QVariant _minForType(void) const;
     QVariant _maxForType(void) const;
     void _setAppSettingsTranslators(void);
+    static FactMetaData* _createFromJsonObject(const QJsonObject& json, QObject* metaDataParent);
 
     // Built in translators
     static QVariant _defaultTranslator(const QVariant& from) { return from; }
@@ -225,6 +228,16 @@ private:
     static const BuiltInTranslation_s _rgBuiltInTranslations[];
 
     static const AppSettingsTranslation_s _rgAppSettingsTranslations[];
+
+    static const char*  _nameJsonKey;
+    static const char*  _decimalPlacesJsonKey;
+    static const char*  _typeJsonKey;
+    static const char*  _shortDescriptionJsonKey;
+    static const char*  _longDescriptionJsonKey;
+    static const char*  _unitsJsonKey;
+    static const char*  _defaultValueJsonKey;
+    static const char*  _minJsonKey;
+    static const char*  _maxJsonKey;
 };
 
 #endif