Expanding rulesets, rules and features implementation

src/Airmap/AirMapFlightManager.cc

@@ -188,7 +188,7 @@ void AirMapFlightManager::_uploadFlight()
         params.end_time     = Clock::universal_time() + Hours{2}; // TODO: user-configurable?
 
         //-- Rules
-        AirMapRulesetsManager* pRulesMgr = dynamic_cast<AirMapRulesetsManager*>(qgcApp()->toolbox()->airspaceManager()->rulesets());
+        AirMapRulesetsManager* pRulesMgr = dynamic_cast<AirMapRulesetsManager*>(qgcApp()->toolbox()->airspaceManager()->ruleSets());
         if(pRulesMgr) {
             foreach(QString ruleset, pRulesMgr->rulesetsIDs()) {
                 params.rulesets.push_back(ruleset.toStdString());

src/Airmap/AirMapRulesetsManager.cc

@@ -15,9 +15,32 @@ using namespace airmap;
 //-----------------------------------------------------------------------------
 AirMapRule::AirMapRule(QObject* parent)
     : AirspaceRule(parent)
+{
+}
+
+//-----------------------------------------------------------------------------
+AirspaceRule::Status
+AirMapRule::status()
+{
+    switch(_rule.status) {
+    case RuleSet::Rule::Status::conflicting:
+        return AirspaceRule::Conflicting;
+    case RuleSet::Rule::Status::not_conflicting:
+        return AirspaceRule::NotConflicting;
+    case RuleSet::Rule::Status::missing_info:
+        return AirspaceRule::MissingInfo;
+    case RuleSet::Rule::Status::unknown:
+    default:
+        return AirspaceRule::Unknown;
+    }
+}
+
+//-----------------------------------------------------------------------------
+AirMapRuleSet::AirMapRuleSet(QObject* parent)
+    : AirspaceRuleSet(parent)
     , _isDefault(false)
     , _selected(false)
-    , _selectionType(AirspaceRule::Optional)
+    , _selectionType(AirspaceRuleSet::Optional)
 {
 }
 
@@ -40,7 +63,7 @@ void AirMapRulesetsManager::setROI(const QGeoCoordinate& center)
     }
     qCDebug(AirMapManagerLog) << "Setting ROI for Rulesets";
     _valid = false;
-    _rules.clearAndDeleteContents();
+    _ruleSets.clearAndDeleteContents();
     _state = State::RetrieveItems;
     RuleSets::Search::Parameters params;
     params.geometry = Geometry::point(center.latitude(), center.longitude());
@@ -50,36 +73,36 @@ void AirMapRulesetsManager::setROI(const QGeoCoordinate& center)
         if (!isAlive.lock()) return;
         if (_state != State::RetrieveItems) return;
         if (result) {
-            const std::vector<RuleSet> rules = result.value();
-            qCDebug(AirMapManagerLog) << "Successful rulesets search. Items:" << rules.size();
-            for (const auto& ruleset : rules) {
-                AirMapRule* pRule = new AirMapRule(this);
-                connect(pRule, &AirspaceRule::selectedChanged, this, &AirMapRulesetsManager::_selectedChanged);
-                pRule->_id          = QString::fromStdString(ruleset.id);
-                pRule->_name        = QString::fromStdString(ruleset.name);
-                pRule->_shortName   = QString::fromStdString(ruleset.short_name);
-                pRule->_description = QString::fromStdString(ruleset.description);
-                pRule->_isDefault   = ruleset.is_default;
+            const std::vector<RuleSet> rulesets = result.value();
+            qCDebug(AirMapManagerLog) << "Successful rulesets search. Items:" << rulesets.size();
+            for (const auto& ruleset : rulesets) {
+                AirMapRuleSet* pRuleSet = new AirMapRuleSet(this);
+                connect(pRuleSet, &AirspaceRuleSet::selectedChanged, this, &AirMapRulesetsManager::_selectedChanged);
+                pRuleSet->_id          = QString::fromStdString(ruleset.id);
+                pRuleSet->_name        = QString::fromStdString(ruleset.name);
+                pRuleSet->_shortName   = QString::fromStdString(ruleset.short_name);
+                pRuleSet->_description = QString::fromStdString(ruleset.description);
+                pRuleSet->_isDefault   = ruleset.is_default;
                 //-- TODO: This should be persistent and if the new incoming set has the
-                //   same, previosuly selected rules, it should "remember".
-                if(pRule->_isDefault) {
-                    pRule->_selected = true;
+                //   same, previosuly selected rulesets, it should "remember".
+                if(pRuleSet->_isDefault) {
+                    pRuleSet->_selected = true;
                 }
                 switch(ruleset.selection_type) {
                 case RuleSet::SelectionType::pickone:
-                    pRule->_selectionType = AirspaceRule::Pickone;
+                    pRuleSet->_selectionType = AirspaceRuleSet::Pickone;
                     break;
                 case RuleSet::SelectionType::required:
-                    pRule->_selectionType = AirspaceRule::Required;
-                    pRule->_selected = true;
+                    pRuleSet->_selectionType = AirspaceRuleSet::Required;
+                    pRuleSet->_selected = true;
                     break;
                 default:
                 case RuleSet::SelectionType::optional:
-                    pRule->_selectionType = AirspaceRule::Optional;
+                    pRuleSet->_selectionType = AirspaceRuleSet::Optional;
                     break;
                 }
-                _rules.append(pRule);
-                qCDebug(AirMapManagerLog) << "Adding rule" << pRule->name();
+                _ruleSets.append(pRuleSet);
+                qCDebug(AirMapManagerLog) << "Adding ruleset" << pRuleSet->name();
                 /*
                 qDebug() << "------------------------------------------";
                 qDebug() << "Jurisdiction:" << ruleset.jurisdiction.name.data() << (int)ruleset.jurisdiction.region;
@@ -92,7 +115,7 @@ void AirMapRulesetsManager::setROI(const QGeoCoordinate& center)
                     qDebug() << airspaceType.data();
                 }
                 qDebug() << "Rules:";
-                for (const auto& rule : ruleset.rules) {
+                for (const auto& rule : ruleset.rulesets) {
                     qDebug() << "    --------------------------------------";
                     qDebug() << "    " << rule.short_text.data();
                     qDebug() << "    " << rule.description.data();
@@ -113,18 +136,18 @@ void AirMapRulesetsManager::setROI(const QGeoCoordinate& center)
             emit error("Failed to retrieve RuleSets", QString::fromStdString(result.error().message()), description);
         }
         _state = State::Idle;
-        emit rulesChanged();
-        emit selectedRulesChanged();
+        emit ruleSetsChanged();
+        emit selectedRuleSetsChanged();
     });
 }
 
 //-----------------------------------------------------------------------------
 QString
-AirMapRulesetsManager::selectedRules()
+AirMapRulesetsManager::selectedRuleSets()
 {
     QString selection;
-    for(int i = 0; i < _rules.count(); i++) {
-        AirMapRule* rule = qobject_cast<AirMapRule*>(_rules.get(i));
+    for(int i = 0; i < _ruleSets.count(); i++) {
+        AirMapRuleSet* rule = qobject_cast<AirMapRuleSet*>(_ruleSets.get(i));
         if(rule && rule->selected()) {
             selection += rule->shortName() + ", ";
         }
@@ -140,7 +163,7 @@ AirMapRulesetsManager::selectedRules()
 void
 AirMapRulesetsManager::_selectedChanged()
 {
-    emit selectedRulesChanged();
+    emit selectedRuleSetsChanged();
     //-- TODO: Do whatever it is you do to select a rule
 }
 
@@ -149,8 +172,8 @@ QStringList
 AirMapRulesetsManager::rulesetsIDs()
 {
     QStringList list;
-    for(int i = 0; i < _rules.count(); i++) {
-        AirMapRule* rule = qobject_cast<AirMapRule*>(_rules.get(i));
+    for(int i = 0; i < _ruleSets.count(); i++) {
+        AirMapRuleSet* rule = qobject_cast<AirMapRuleSet*>(_ruleSets.get(i));
         if(rule && rule->selected()) {
             list << rule->id();
         }

src/Airmap/AirMapRulesetsManager.h

@@ -25,11 +25,27 @@
 
 //-----------------------------------------------------------------------------
 class AirMapRule : public AirspaceRule
+{
+    Q_OBJECT
+public:
+
+    AirMapRule(QObject* parent = NULL);
+
+    Status          status          () override;
+    QString         shortText       () override { return QString::fromStdString(_rule.short_text);  }
+    QString         description     () override { return QString::fromStdString(_rule.description); }
+
+private:
+    airmap::RuleSet::Rule _rule;
+};
+
+//-----------------------------------------------------------------------------
+class AirMapRuleSet : public AirspaceRuleSet
 {
     Q_OBJECT
     friend class AirMapRulesetsManager;
 public:
-    AirMapRule                  (QObject* parent = NULL);
+    AirMapRuleSet                  (QObject* parent = NULL);
     QString         id              () override { return _id; }
     QString         description     () override { return _description; }
     bool            isDefault       () override { return _isDefault; }
@@ -38,6 +54,7 @@ public:
     SelectionType   selectionType   () override { return _selectionType; }
     bool            selected        () override { return _selected; }
     void            setSelected     (bool sel) override { _selected = sel; emit selectedChanged(); }
+    QmlObjectListModel* rules       () override { return &_rules; }
 private:
     QString             _id;
     QString             _description;
@@ -46,6 +63,7 @@ private:
     QString             _name;
     QString             _shortName;
     SelectionType       _selectionType;
+    QmlObjectListModel  _rules;
 };
 
 //-----------------------------------------------------------------------------
@@ -56,8 +74,8 @@ public:
     AirMapRulesetsManager       (AirMapSharedState& shared);
 
     bool                valid       () override { return _valid; }
-    QmlObjectListModel* rules       () override { return &_rules; }
-    QString            selectedRules() override;
+    QmlObjectListModel* ruleSets    () override { return &_ruleSets; }
+    QString            selectedRuleSets() override;
 
     void                setROI      (const QGeoCoordinate& center) override;
 
@@ -78,7 +96,7 @@ private:
     bool                            _valid;
     State                           _state = State::Idle;
     AirMapSharedState&              _shared;
-    QmlObjectListModel              _rules;
+    QmlObjectListModel              _ruleSets;
 };
 
 

src/Airmap/AirspaceControl.qml

@@ -290,7 +290,7 @@ Item {
                                     Layout.fillWidth:       true
                                     QGCLabel {
                                         id:                     regLabel
-                                        text:                   _validRules ? _activeVehicle.airspaceController.rulesets.selectedRules : qsTr("None")
+                                        text:                   _validRules ? _activeVehicle.airspaceController.ruleSets.selectedRuleSets : qsTr("None")
                                         elide:                  Text.ElideRight
                                         horizontalAlignment:    Text.AlignHCenter
                                         color:                  _colorWhite
@@ -425,9 +425,9 @@ Item {
                                 anchors.leftMargin: ScreenTools.defaultFontPixelWidth * 2
                             }
                             Repeater {
-                                model:    _validRules ? _activeVehicle.airspaceController.rulesets.rules : []
+                                model:    _validRules ? _activeVehicle.airspaceController.rulesets.ruleSets : []
                                 delegate: RuleSelector {
-                                    visible:             object.selectionType === AirspaceRule.Pickone
+                                    visible:             object.selectionType === AirspaceRuleSet.Pickone
                                     rule:                object
                                     exclusiveGroup:      rulesGroup
                                     anchors.right:       parent.right
@@ -446,9 +446,9 @@ Item {
                                 anchors.leftMargin: ScreenTools.defaultFontPixelWidth * 2
                             }
                             Repeater {
-                                model:    _validRules ? _activeVehicle.airspaceController.rulesets.rules : []
+                                model:    _validRules ? _activeVehicle.airspaceController.rulesets.ruleSets : []
                                 delegate: RuleSelector {
-                                    visible:             object.selectionType === AirspaceRule.Optional
+                                    visible:             object.selectionType === AirspaceRuleSet.Optional
                                     rule:                object
                                     anchors.right:       parent.right
                                     anchors.rightMargin: ScreenTools.defaultFontPixelWidth
@@ -466,9 +466,9 @@ Item {
                                 anchors.leftMargin: ScreenTools.defaultFontPixelWidth * 2
                             }
                             Repeater {
-                                model:    _validRules ? _activeVehicle.airspaceController.rulesets.rules : []
+                                model:    _validRules ? _activeVehicle.airspaceController.rulesets.ruleSets : []
                                 delegate: RuleSelector {
-                                    visible:             object.selectionType === AirspaceRule.Required
+                                    visible:             object.selectionType === AirspaceRuleSet.Required
                                     rule:                object
                                     required:            true
                                     anchors.right:       parent.right

src/AirspaceManagement/AirspaceController.cc

@@ -48,9 +48,9 @@ AirspaceController::advisories()
 }
 
 AirspaceRulesetsProvider*
-AirspaceController::rulesets()
+AirspaceController::ruleSets()
 {
-    return _manager->rulesets();
+    return _manager->ruleSets();
 }
 
 AirspaceRestrictionProvider*

src/AirspaceManagement/AirspaceController.h

@@ -29,7 +29,7 @@ public:
     Q_PROPERTY(QString                      providerName        READ providerName       CONSTANT)
     Q_PROPERTY(AirspaceWeatherInfoProvider* weatherInfo         READ weatherInfo        CONSTANT)
     Q_PROPERTY(AirspaceAdvisoryProvider*    advisories          READ advisories         CONSTANT)
-    Q_PROPERTY(AirspaceRulesetsProvider*    rulesets            READ rulesets           CONSTANT)
+    Q_PROPERTY(AirspaceRulesetsProvider*    ruleSets            READ ruleSets           CONSTANT)
     Q_PROPERTY(AirspaceRestrictionProvider* airspaces           READ airspaces          CONSTANT)
     Q_PROPERTY(bool                         airspaceVisible     READ airspaceVisible    WRITE setairspaceVisible    NOTIFY airspaceVisibleChanged)
 
@@ -38,7 +38,7 @@ public:
     QString                         providerName        ();
     AirspaceWeatherInfoProvider*    weatherInfo         ();
     AirspaceAdvisoryProvider*       advisories          ();
-    AirspaceRulesetsProvider*       rulesets            ();
+    AirspaceRulesetsProvider*       ruleSets            ();
     AirspaceRestrictionProvider*    airspaces           ();
     bool                            airspaceVisible     () { return _airspaceVisible; }
 

src/AirspaceManagement/AirspaceManager.cc

@@ -28,11 +28,14 @@ AirspaceManager::AirspaceManager(QGCApplication* app, QGCToolbox* toolbox)
     _roiUpdateTimer.setInterval(2000);
     _roiUpdateTimer.setSingleShot(true);
     connect(&_roiUpdateTimer, &QTimer::timeout, this, &AirspaceManager::_updateToROI);
+    //-- TODO: Move these away from QGroundControl and into their own group (Airspace)
     qmlRegisterUncreatableType<AirspaceAuthorization>       ("QGroundControl",              1, 0, "AirspaceAuthorization",          "Reference only");
     qmlRegisterUncreatableType<AirspaceController>          ("QGroundControl.Vehicle",      1, 0, "AirspaceController",             "Reference only");
     qmlRegisterUncreatableType<AirspaceWeatherInfoProvider> ("QGroundControl.Vehicle",      1, 0, "AirspaceWeatherInfoProvider",    "Reference only");
     qmlRegisterUncreatableType<AirspaceAdvisoryProvider>    ("QGroundControl.Vehicle",      1, 0, "AirspaceAdvisoryProvider",       "Reference only");
+    qmlRegisterUncreatableType<AirspaceRuleFeature>         ("QGroundControl.Vehicle",      1, 0, "AirspaceRuleFeature",            "Reference only");
     qmlRegisterUncreatableType<AirspaceRule>                ("QGroundControl.Vehicle",      1, 0, "AirspaceRule",                   "Reference only");
+    qmlRegisterUncreatableType<AirspaceRuleSet>             ("QGroundControl.Vehicle",      1, 0, "AirspaceRuleSet",                "Reference only");
     qmlRegisterUncreatableType<AirspaceRulesetsProvider>    ("QGroundControl.Vehicle",      1, 0, "AirspaceRulesetsProvider",       "Reference only");
     qmlRegisterUncreatableType<AirspaceRestrictionProvider> ("QGroundControl.Vehicle",      1, 0, "AirspaceRestrictionProvider",    "Reference only");
 }
@@ -45,8 +48,8 @@ AirspaceManager::~AirspaceManager()
     if(_weatherProvider) {
         delete _weatherProvider;
     }
-    if(_rulesetsProvider) {
-        delete _rulesetsProvider;
+    if(_ruleSetsProvider) {
+        delete _ruleSetsProvider;
     }
     if(_airspaces) {
         delete _airspaces;
@@ -57,7 +60,7 @@ void AirspaceManager::setToolbox(QGCToolbox* toolbox)
 {
     QGCTool::setToolbox(toolbox);
     // We should not call virtual methods in the constructor, so we instantiate the restriction provider here
-    _rulesetsProvider   = instantiateRulesetsProvider();
+    _ruleSetsProvider   = instantiateRulesetsProvider();
     _weatherProvider    = instatiateAirspaceWeatherInfoProvider();
     _advisories         = instatiateAirspaceAdvisoryProvider();
     _airspaces          = instantiateAirspaceRestrictionProvider();
@@ -75,8 +78,8 @@ void AirspaceManager::_updateToROI()
     if(_airspaces) {
         _airspaces->setROI(_roiCenter, _roiRadius);
     }
-    if(_rulesetsProvider) {
-        _rulesetsProvider->setROI(_roiCenter);
+    if(_ruleSetsProvider) {
+        _ruleSetsProvider->setROI(_roiCenter);
     }
     if(_weatherProvider) {
         _weatherProvider->setROI(_roiCenter);

src/AirspaceManagement/AirspaceManager.h

@@ -88,7 +88,7 @@ public:
 
     AirspaceWeatherInfoProvider* weatherInfo    () { return _weatherProvider; }
     AirspaceAdvisoryProvider*    advisories     () { return _advisories; }
-    AirspaceRulesetsProvider*    rulesets       () { return _rulesetsProvider; }
+    AirspaceRulesetsProvider*    ruleSets       () { return _ruleSetsProvider; }
     AirspaceRestrictionProvider* airspaces      () { return _airspaces; }
 
     void setToolbox(QGCToolbox* toolbox) override;
@@ -101,7 +101,7 @@ public:
 private:
     void _updateToROI   ();
 
-    AirspaceRulesetsProvider*       _rulesetsProvider       = nullptr; ///< Rulesets that are shown in the UI
+    AirspaceRulesetsProvider*       _ruleSetsProvider       = nullptr; ///< Rulesets that are shown in the UI
     AirspaceWeatherInfoProvider*    _weatherProvider        = nullptr; ///< Weather info that is shown in the UI
     AirspaceAdvisoryProvider*       _advisories             = nullptr; ///< Advisory info that is shown in the UI
     AirspaceRestrictionProvider*    _airspaces              = nullptr; ///< Airspace info that is shown in the UI

src/AirspaceManagement/AirspaceRulesetsProvider.cc

@@ -9,7 +9,12 @@
 
 #include "AirspaceRulesetsProvider.h"
 
-AirspaceRule::AirspaceRule(QObject* parent)
+AirspaceRule::AirspaceRule(QObject *parent)
+    : QObject(parent)
+{
+}
+
+AirspaceRuleSet::AirspaceRuleSet(QObject* parent)
     : QObject(parent)
 {
 }

src/AirspaceManagement/AirspaceRulesetsProvider.h

@@ -20,8 +20,81 @@
 #include <QObject>
 #include <QGeoCoordinate>
 
+//-----------------------------------------------------------------------------
+class AirspaceRuleFeature : public QObject
+{
+    Q_OBJECT
+public:
+
+    enum Type {
+        Unknown,
+        Boolean,
+        Float,
+        String,
+    };
+
+    enum Measurement {
+        UnknownMeasurement,
+        Speed,
+        Weight,
+        Distance,
+    };
+
+    enum Unit {
+        UnknownUnit,
+        Kilogram,
+        Meters,
+        MetersPerSecond,
+    };
+
+    Q_ENUM(Type)
+    Q_ENUM(Measurement)
+    Q_ENUM(Unit)
+
+    AirspaceRuleFeature(QObject* parent = NULL);
+
+    Q_PROPERTY(Type             type            READ type           CONSTANT)
+    Q_PROPERTY(Measurement      measurement     READ measurement    CONSTANT)
+    Q_PROPERTY(QString          name            READ name           CONSTANT)
+    Q_PROPERTY(QString          description     READ description    CONSTANT)
+    Q_PROPERTY(QVariant         value           READ description    CONSTANT)
+
+    virtual Measurement     measurement     () = 0;
+    virtual Type            type            () = 0;
+    virtual QString         name            () = 0;
+    virtual QString         description     () = 0;
+    virtual QVariant        value           () = 0;
+};
+
 //-----------------------------------------------------------------------------
 class AirspaceRule : public QObject
+{
+    Q_OBJECT
+public:
+
+    enum Status {
+        Unknown,                ///< The status of the rule is unknown.
+        Conflicting,            ///< The rule is conflicting.
+        NotConflicting,         ///< The rule is not conflicting, all good to go.
+        MissingInfo,            ///< The evaluation requires further information.
+        Informational           ///< The rule is of informational nature.
+    };
+
+    Q_ENUM(Status)
+
+    AirspaceRule(QObject* parent = NULL);
+
+    Q_PROPERTY(Status           status          READ status         CONSTANT)
+    Q_PROPERTY(QString          shortText       READ shortText      CONSTANT)
+    Q_PROPERTY(QString          description     READ description    CONSTANT)
+
+    virtual Status          status          () = 0;
+    virtual QString         shortText       () = 0;
+    virtual QString         description     () = 0;
+};
+
+//-----------------------------------------------------------------------------
+class AirspaceRuleSet : public QObject
 {
     Q_OBJECT
 public:
@@ -34,7 +107,7 @@ public:
 
     Q_ENUM(SelectionType)
 
-    AirspaceRule(QObject* parent = NULL);
+    AirspaceRuleSet(QObject* parent = NULL);
 
     Q_PROPERTY(QString          id              READ id             CONSTANT)
     Q_PROPERTY(QString          name            READ name           CONSTANT)
@@ -43,6 +116,7 @@ public:
     Q_PROPERTY(bool             isDefault       READ isDefault      CONSTANT)
     Q_PROPERTY(SelectionType    selectionType   READ selectionType  CONSTANT)
     Q_PROPERTY(bool             selected        READ selected       WRITE setSelected   NOTIFY selectedChanged)
+    Q_PROPERTY(QmlObjectListModel* rules        READ rules          CONSTANT)
 
     virtual QString         id              () = 0;
     virtual QString         description     () = 0;
@@ -52,6 +126,7 @@ public:
     virtual SelectionType   selectionType   () = 0;
     virtual bool            selected        () = 0;
     virtual void            setSelected     (bool sel) = 0;
+    virtual QmlObjectListModel* rules       () = 0;             ///< List of AirspaceRule
 
 signals:
     void    selectedChanged                 ();
@@ -65,13 +140,13 @@ public:
     AirspaceRulesetsProvider        (QObject* parent = NULL);
     ~AirspaceRulesetsProvider       () = default;
 
-    Q_PROPERTY(bool                 valid           READ valid          NOTIFY rulesChanged)
-    Q_PROPERTY(QString              selectedRules   READ selectedRules  NOTIFY selectedRulesChanged)
-    Q_PROPERTY(QmlObjectListModel*  rules           READ rules          NOTIFY rulesChanged)
+    Q_PROPERTY(bool                 valid               READ valid              NOTIFY ruleSetsChanged)
+    Q_PROPERTY(QString              selectedRuleSets    READ selectedRuleSets   NOTIFY selectedRuleSetsChanged)
+    Q_PROPERTY(QmlObjectListModel*  ruleSets            READ ruleSets           NOTIFY ruleSetsChanged)
 
     virtual bool                valid       () = 0;             ///< Current ruleset is valid
-    virtual QmlObjectListModel* rules       () = 0;             ///< List of AirspaceRule
-    virtual QString            selectedRules() = 0;             ///< All selected rules concatenated into a string
+    virtual QmlObjectListModel* ruleSets    () = 0;             ///< List of AirspaceRuleSet
+    virtual QString         selectedRuleSets() = 0;             ///< All selected rules concatenated into a string
     /**
      * Set region of interest that should be queried. When finished, the rulesChanged() signal will be emmited.
      * @param center Center coordinate for ROI
@@ -79,7 +154,7 @@ public:
     virtual void        setROI      (const QGeoCoordinate& center) = 0;
 
 signals:
-    void rulesChanged               ();
-    void selectedRulesChanged       ();
+    void ruleSetsChanged            ();
+    void selectedRuleSetsChanged    ();
 };