refs #395, integrated aircraft airspace snapshot / analyzer into remote provider

* added snapshot class
* added snapshot in analyzer, signal for new snapshot
* made all provider signals available in CSimulator
* added finders in CSimulatedAircraftList
* moved COwnAircraftProviderDummy into own file

src/blackmisc/simulation/airspaceaircraftsnapshot.cpp

@@ -0,0 +1,59 @@
+/* Copyright (C) 2015
+ * swift project Community / Contributors
+ *
+ * This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
+ * directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
+ * including this file, may be copied, modified, propagated, or distributed except according to the terms
+ * contained in the LICENSE file.
+ */
+
+#include "airspaceaircraftsnapshot.h"
+
+using namespace BlackMisc::Aviation;
+
+namespace BlackMisc
+{
+    namespace Simulation
+    {
+        CAirspaceAircraftSnapshot::CAirspaceAircraftSnapshot()
+        { }
+
+        CAirspaceAircraftSnapshot::CAirspaceAircraftSnapshot(const CSimulatedAircraftList &allAircraft)
+        {
+            if (!allAircraft.isEmpty())
+            {
+                CSimulatedAircraftList aircraft(allAircraft);
+                aircraft.sortByDistanceToOwnAircraft();
+                CSimulatedAircraftList vtolAircraft(aircraft.findByVtol(true));
+                m_aircraftCallsignsByDistance = aircraft.getCallsigns();
+                m_enabledAircraftCallsignsByDistance = aircraft.findByEnabled(true).getCallsigns();
+                m_disabledAircraftCallsignsByDistance = aircraft.findByEnabled(false).getCallsigns();
+                m_vtolAircraftCallsignsByDistance = vtolAircraft.getCallsigns();
+                m_enabledVtolAircraftCallsignsByDistance = vtolAircraft.findByEnabled(true).getCallsigns();
+            }
+        }
+
+        CVariant CAirspaceAircraftSnapshot::propertyByIndex(const CPropertyIndex &index) const
+        {
+            if (index.isMyself()) { return this->toCVariant(); }
+            return CValueObject::propertyByIndex(index);
+        }
+
+        void CAirspaceAircraftSnapshot::setPropertyByIndex(const CVariant &variant, const CPropertyIndex &index)
+        {
+            if (index.isMyself())
+            {
+                this->convertFromCVariant(variant);
+                return;
+            }
+            CValueObject::setPropertyByIndex(variant, index);
+        }
+
+        QString CAirspaceAircraftSnapshot::convertToQString(bool i18n) const
+        {
+            Q_UNUSED(i18n);
+            return this->getTimestamp().toString();
+        }
+
+    } // ns
+} // ns

src/blackmisc/simulation/airspaceaircraftsnapshot.h

@@ -0,0 +1,91 @@
+/* Copyright (C) 2015
+ * swift project Community / Contributors
+ *
+ * This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
+ * directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
+ * including this file, may be copied, modified, propagated, or distributed except according to the terms
+ * contained in the LICENSE file.
+ */
+
+//! \file
+
+#ifndef BLACKMISC_SIMULATION_AIRSPACEAIRCRAFTANALYZER_H
+#define BLACKMISC_SIMULATION_AIRSPACEAIRCRAFTANALYZER_H
+
+#include "blackmisc/simulation/simulatedaircraftlist.h"
+#include "blackmisc/aviation/callsignset.h"
+#include "blackmisc/propertyindex.h"
+#include <QDateTime>
+
+namespace BlackMisc
+{
+    namespace Simulation
+    {
+        //! Current situation in the sky analyzed.
+        class CAirspaceAircraftSnapshot : public CValueObject<CAirspaceAircraftSnapshot>
+        {
+        public:
+            //! Default constructor
+            CAirspaceAircraftSnapshot();
+
+            //! Constructor
+            CAirspaceAircraftSnapshot(const BlackMisc::Simulation::CSimulatedAircraftList &allAircraft);
+
+            //! Time when snapshot was taken
+            const QDateTime getTimestamp() const { return QDateTime::fromMSecsSinceEpoch(m_timestampMsSinceEpoch); }
+
+            //! Callsigns by distance
+            const BlackMisc::Aviation::CCallsignSet &getAircraftCallsignsByDistance() const { return m_aircraftCallsignsByDistance; }
+
+            //! Callsigns by distance, only enabled aircraft
+            const BlackMisc::Aviation::CCallsignSet &getEnabledAircraftCallsignsByDistance() const { return m_enabledAircraftCallsignsByDistance; }
+
+            //! Callsigns by distance, only disabled aircraft
+            const BlackMisc::Aviation::CCallsignSet &getDisabledAircraftCallsignsByDistance() const { return m_disabledAircraftCallsignsByDistance; }
+
+            //! VTOL aircraft callsigns by distance, only enabled aircraft
+            const BlackMisc::Aviation::CCallsignSet &getVtolAircraftCallsignsByDistance() const { return m_vtolAircraftCallsignsByDistance; }
+
+            //! VTOL aircraft callsigns by distance, only enabled aircraft
+            const BlackMisc::Aviation::CCallsignSet &getEnabledVtolAircraftCallsignsByDistance() const { return m_enabledVtolAircraftCallsignsByDistance; }
+
+            //! \copydoc CValueObject::propertyByIndex
+            virtual CVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override;
+
+            //! \copydoc CValueObject::setPropertyByIndex
+            virtual void setPropertyByIndex(const CVariant &variant, const BlackMisc::CPropertyIndex &index) override;
+
+        protected:
+            //! \copydoc CValueObject::convertToQString
+            virtual QString convertToQString(bool i18n = false) const override;
+
+        private:
+            BLACK_ENABLE_TUPLE_CONVERSION(CAirspaceAircraftSnapshot)
+            qint64 m_timestampMsSinceEpoch;
+
+            // remark closest aircraft always first
+            BlackMisc::Aviation::CCallsignSet m_aircraftCallsignsByDistance;
+
+            BlackMisc::Aviation::CCallsignSet m_enabledAircraftCallsignsByDistance;
+            BlackMisc::Aviation::CCallsignSet m_disabledAircraftCallsignsByDistance;
+
+            BlackMisc::Aviation::CCallsignSet m_vtolAircraftCallsignsByDistance;
+            BlackMisc::Aviation::CCallsignSet m_enabledVtolAircraftCallsignsByDistance;
+
+        };
+
+    } // namespace
+} // namespace
+
+BLACK_DECLARE_TUPLE_CONVERSION(
+    BlackMisc::Simulation::CAirspaceAircraftSnapshot, (
+        attr(o.m_timestampMsSinceEpoch),
+        attr(o.m_aircraftCallsignsByDistance, flags<DisabledForComparison>()),
+        attr(o.m_enabledAircraftCallsignsByDistance, flags <DisabledForComparison> ()),
+        attr(o.m_disabledAircraftCallsignsByDistance, flags<DisabledForComparison>()),
+        attr(o.m_vtolAircraftCallsignsByDistance, flags <DisabledForComparison> ()),
+        attr(o.m_enabledVtolAircraftCallsignsByDistance, flags<DisabledForComparison>())
+    ))
+Q_DECLARE_METATYPE(BlackMisc::Simulation::CAirspaceAircraftSnapshot)
+
+#endif

src/blackmisc/simulation/ownaircraftprovider.cpp

@@ -96,88 +96,5 @@ namespace BlackMisc
             return this->m_ownAircraftProvider->updateOwnIcaoData(icaoData);
         }
 
-        Geo::CCoordinateGeodetic COwnAircraftProviderDummy::getOwnAircraftPosition() const
-        {
-            return m_ownAircraft.getPosition();
-        }
-
-        CAircraftParts COwnAircraftProviderDummy::getOwnAircraftParts() const
-        {
-            return m_ownAircraft.getParts();
-        }
-
-        CAircraftModel COwnAircraftProviderDummy::getOwnAircraftModel() const
-        {
-            return m_ownAircraft.getModel();
-        }
-
-        CLength COwnAircraftProviderDummy::getDistanceToOwnAircraft(const Geo::ICoordinateGeodetic &position) const
-        {
-            return m_ownAircraft.calculateGreatCircleDistance(position);
-        }
-
-        bool COwnAircraftProviderDummy::updateCockpit(const Aviation::CComSystem &com1, const Aviation::CComSystem &com2, const Aviation::CTransponder &transponder, const QString &originator)
-        {
-            m_ownAircraft.setCom1System(com1);
-            m_ownAircraft.setCom2System(com2);
-            m_ownAircraft.setTransponder(transponder);
-            Q_UNUSED(originator);
-            return true;
-        }
-
-        bool COwnAircraftProviderDummy::updateActiveComFrequency(const PhysicalQuantities::CFrequency &frequency, int comUnit, const QString &originator)
-        {
-            if (!CComSystem::isValidComFrequency(frequency)) { return false; }
-            CComSystem::ComUnit comUnitEnum = static_cast<CComSystem::ComUnit>(comUnit);
-            CComSystem com = m_ownAircraft.getComSystem(comUnitEnum);
-            com.setFrequencyActive(frequency);
-            m_ownAircraft.setComSystem(com, comUnitEnum);
-            Q_UNUSED(originator);
-            return true;
-        }
-
-        bool COwnAircraftProviderDummy::updateSelcal(const CSelcal &selcal, const QString &originator)
-        {
-            m_ownAircraft.setSelcal(selcal);
-            Q_UNUSED(originator);
-            return true;
-        }
-
-        bool COwnAircraftProviderDummy::updateOwnModel(const CAircraftModel &model)
-        {
-            m_ownAircraft.setModel(model);
-            return true;
-        }
-
-        bool COwnAircraftProviderDummy::updateOwnSituation(const CAircraftSituation &situation)
-        {
-            m_ownAircraft.setSituation(situation);
-            return true;
-        }
-
-        bool COwnAircraftProviderDummy::updateOwnParts(const CAircraftParts &parts)
-        {
-            m_ownAircraft.setParts(parts);
-            return true;
-        }
-
-        bool COwnAircraftProviderDummy::updateOwnCallsign(const CCallsign &callsign)
-        {
-            m_ownAircraft.setCallsign(callsign);
-            return true;
-        }
-
-        bool COwnAircraftProviderDummy::updateOwnIcaoData(const CAircraftIcao &icaoData)
-        {
-            m_ownAircraft.setIcaoInfo(icaoData);
-            return true;
-        }
-
-        COwnAircraftProviderDummy *COwnAircraftProviderDummy::instance()
-        {
-            static COwnAircraftProviderDummy *dummy = new COwnAircraftProviderDummy();
-            return dummy;
-        }
-
     } // namespace
 } // namespace

src/blackmisc/simulation/ownaircraftproviderdummy.cpp

@@ -0,0 +1,104 @@
+/* Copyright (C) 2015
+ * swift project Community / Contributors
+ *
+ * This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
+ * directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
+ * including this file, may be copied, modified, propagated, or distributed except according to the terms
+ * contained in the LICENSE file.
+ */
+
+#include "ownaircraftproviderdummy.h"
+
+using namespace BlackMisc::Aviation;
+using namespace BlackMisc::PhysicalQuantities;
+
+namespace BlackMisc
+{
+    namespace Simulation
+    {
+
+        Geo::CCoordinateGeodetic COwnAircraftProviderDummy::getOwnAircraftPosition() const
+        {
+            return m_ownAircraft.getPosition();
+        }
+
+        CAircraftParts COwnAircraftProviderDummy::getOwnAircraftParts() const
+        {
+            return m_ownAircraft.getParts();
+        }
+
+        CAircraftModel COwnAircraftProviderDummy::getOwnAircraftModel() const
+        {
+            return m_ownAircraft.getModel();
+        }
+
+        CLength COwnAircraftProviderDummy::getDistanceToOwnAircraft(const Geo::ICoordinateGeodetic &position) const
+        {
+            return m_ownAircraft.calculateGreatCircleDistance(position);
+        }
+
+        bool COwnAircraftProviderDummy::updateCockpit(const Aviation::CComSystem &com1, const Aviation::CComSystem &com2, const Aviation::CTransponder &transponder, const QString &originator)
+        {
+            m_ownAircraft.setCom1System(com1);
+            m_ownAircraft.setCom2System(com2);
+            m_ownAircraft.setTransponder(transponder);
+            Q_UNUSED(originator);
+            return true;
+        }
+
+        bool COwnAircraftProviderDummy::updateActiveComFrequency(const PhysicalQuantities::CFrequency &frequency, int comUnit, const QString &originator)
+        {
+            if (!CComSystem::isValidComFrequency(frequency)) { return false; }
+            CComSystem::ComUnit comUnitEnum = static_cast<CComSystem::ComUnit>(comUnit);
+            CComSystem com = m_ownAircraft.getComSystem(comUnitEnum);
+            com.setFrequencyActive(frequency);
+            m_ownAircraft.setComSystem(com, comUnitEnum);
+            Q_UNUSED(originator);
+            return true;
+        }
+
+        bool COwnAircraftProviderDummy::updateSelcal(const CSelcal &selcal, const QString &originator)
+        {
+            m_ownAircraft.setSelcal(selcal);
+            Q_UNUSED(originator);
+            return true;
+        }
+
+        bool COwnAircraftProviderDummy::updateOwnModel(const CAircraftModel &model)
+        {
+            m_ownAircraft.setModel(model);
+            return true;
+        }
+
+        bool COwnAircraftProviderDummy::updateOwnSituation(const CAircraftSituation &situation)
+        {
+            m_ownAircraft.setSituation(situation);
+            return true;
+        }
+
+        bool COwnAircraftProviderDummy::updateOwnParts(const CAircraftParts &parts)
+        {
+            m_ownAircraft.setParts(parts);
+            return true;
+        }
+
+        bool COwnAircraftProviderDummy::updateOwnCallsign(const CCallsign &callsign)
+        {
+            m_ownAircraft.setCallsign(callsign);
+            return true;
+        }
+
+        bool COwnAircraftProviderDummy::updateOwnIcaoData(const CAircraftIcao &icaoData)
+        {
+            m_ownAircraft.setIcaoInfo(icaoData);
+            return true;
+        }
+
+        COwnAircraftProviderDummy *COwnAircraftProviderDummy::instance()
+        {
+            static COwnAircraftProviderDummy *dummy = new COwnAircraftProviderDummy();
+            return dummy;
+        }
+
+    } // namespace
+} // namespace

src/blackmisc/simulation/ownaircraftproviderdummy.h

@@ -0,0 +1,82 @@
+/* Copyright (C) 2015
+ * swift project Community / Contributors
+ *
+ * This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
+ * directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
+ * including this file, may be copied, modified, propagated, or distributed except according to the terms
+ * contained in the LICENSE file.
+ */
+
+//! \file
+
+#ifndef BLACKMISC_SIMULATION_OWNAIRCRAFTPROVIDERDUMMY_H
+#define BLACKMISC_SIMULATION_OWNAIRCRAFTPROVIDERDUMMY_H
+
+#include "blackmisc/simulation/ownaircraftprovider.h"
+
+namespace BlackMisc
+{
+    namespace Simulation
+    {
+        //! For testing, thread safety not implemented in this class
+        class COwnAircraftProviderDummy :
+            public QObject,
+            public IOwnAircraftProvider
+        {
+            Q_OBJECT
+
+        public:
+            //! Constructor
+            COwnAircraftProviderDummy() = default;
+
+            //! Singleton
+            static COwnAircraftProviderDummy *instance();
+
+            //! \copydoc IOwnAircraftProvider::getOwnAircraft
+            virtual CSimulatedAircraft getOwnAircraft() const override { return this->m_ownAircraft; }
+
+            //! \copydoc IOwnAircraftProvider::getOwnAircraftPosition
+            virtual BlackMisc::Geo::CCoordinateGeodetic getOwnAircraftPosition() const override;
+
+            //! \copydoc IOwnAircraftProvider::getOwnAircraftParts
+            virtual BlackMisc::Aviation::CAircraftParts getOwnAircraftParts() const override;
+
+            //! \copydoc IOwnAircraftProvider::getOwnAircraftModel
+            virtual BlackMisc::Simulation::CAircraftModel getOwnAircraftModel() const;
+
+            //! \copydoc IOwnAircraftProvider::getDistanceToOwnAircraft
+            virtual BlackMisc::PhysicalQuantities::CLength getDistanceToOwnAircraft(const BlackMisc::Geo::ICoordinateGeodetic &position) const override;
+
+        public slots:
+            //! \copydoc IOwnAircraftProvider::updateCockpit
+            virtual bool updateCockpit(const BlackMisc::Aviation::CComSystem &com1, const BlackMisc::Aviation::CComSystem &com2, const BlackMisc::Aviation::CTransponder &transponder, const QString &originator) override;
+
+            //! \copydoc IOwnAircraftProvider::updateComFrequency
+            virtual bool updateActiveComFrequency(const BlackMisc::PhysicalQuantities::CFrequency &frequency, int comUnit, const QString &originator) override;
+
+            //! \copydoc IOwnAircraftProvider::updateSelcal
+            virtual bool updateSelcal(const BlackMisc::Aviation::CSelcal &selcal, const QString &originator) override;
+
+            //! \copydoc IOwnAircraftProvider::updateOwnCallsign
+            virtual bool updateOwnCallsign(const BlackMisc::Aviation::CCallsign &callsign) override;
+
+            //! \copydoc IOwnAircraftProvider::updateOwnModel
+            virtual bool updateOwnModel(const BlackMisc::Simulation::CAircraftModel &model) override;
+
+            //! \copydoc IOwnAircraftProvider::updateOwnIcaoData
+            virtual bool updateOwnIcaoData(const BlackMisc::Aviation::CAircraftIcao &icaoData) override;
+
+            //! \copydoc IOwnAircraftProvider::updateOwnSituation
+            virtual bool updateOwnSituation(const BlackMisc::Aviation::CAircraftSituation &situation) override;
+
+            //! \copydoc IOwnAircraftProvider::updateOwnParts
+            virtual bool updateOwnParts(const BlackMisc::Aviation::CAircraftParts &parts) override;
+
+        private:
+            BlackMisc::Simulation::CSimulatedAircraft m_ownAircraft;
+        };
+
+    } // namespace
+} // namespace
+
+#endif // guard

src/blackmisc/simulation/remoteaircraftproviderdummy.cpp

@@ -34,6 +34,11 @@ namespace BlackMisc
             return m_aircraft.findFirstByCallsign(callsign);
         }
 
+        CAirspaceAircraftSnapshot CRemoteAircraftProviderDummy::getLatestAirspaceAircraftSnapshot() const
+        {
+            return CAirspaceAircraftSnapshot(m_aircraft);
+        }
+
         CAircraftPartsList CRemoteAircraftProviderDummy::remoteAircraftParts(const BlackMisc::Aviation::CCallsign &callsign, qint64 cutoffTimeBefore) const
         {
             if (cutoffTimeBefore < 0) { return m_parts.findByCallsign(callsign); }
@@ -60,12 +65,19 @@ namespace BlackMisc
             return remoteAircraftParts(callsign).size() > 0;
         }
 
-        bool CRemoteAircraftProviderDummy::connectRemoteAircraftProviderSignals(std::function<void (const CAircraftSituation &)> situationSlot, std::function<void (const CAircraftParts &)> partsSlot, std::function<void (const CCallsign &)> removedAircraftSlot)
+        bool CRemoteAircraftProviderDummy::connectRemoteAircraftProviderSignals(
+            std::function<void (const CAircraftSituation &)>        situationSlot,
+            std::function<void (const CAircraftParts &)>            partsSlot,
+            std::function<void (const CCallsign &)>                 removedAircraftSlot,
+            std::function<void (const CAirspaceAircraftSnapshot &)> aircraftSnapshotSlot
+        )
         {
             bool s1 = connect(this, &CRemoteAircraftProviderDummy::addedRemoteAircraftSituation, situationSlot);
             bool s2 = connect(this, &CRemoteAircraftProviderDummy::addedRemoteAircraftParts, partsSlot);
             bool s3 = connect(this, &CRemoteAircraftProviderDummy::removedRemoteAircraft, removedAircraftSlot);
-            return s1 && s2 && s3;
+            bool s4 = connect(this, &CRemoteAircraftProviderDummy::airspaceAircraftSnapshot, aircraftSnapshotSlot);
+
+            return s1 && s2 && s3 && s4;
         }
 
         bool CRemoteAircraftProviderDummy::updateAircraftEnabled(const CCallsign &callsign, bool enabledForRendering, const QString &originator)

src/blackmisc/simulation/remoteaircraftproviderdummy.h

@@ -41,6 +41,9 @@ namespace BlackMisc
             //! IRemoteAircraftProvider::getAircraftInRangeForCallsign
             virtual BlackMisc::Simulation::CSimulatedAircraft getAircraftInRangeForCallsign(const BlackMisc::Aviation::CCallsign &callsign) const override;
 
+            //! \copydoc IRemoteAircraftProvider::getLatestAirspaceAircraftSnapshot
+            virtual BlackMisc::Simulation::CAirspaceAircraftSnapshot getLatestAirspaceAircraftSnapshot() const override;
+
             //! \copydoc IRemoteAircraftProvider::remoteAircraftParts
             virtual BlackMisc::Aviation::CAircraftPartsList remoteAircraftParts(const Aviation::CCallsign &callsign, qint64 cutoffTimeBefore = -1) const override;
 
@@ -58,9 +61,10 @@ namespace BlackMisc
 
             //! \copydoc IRemoteAircraftProvider::connectRemoteAircraftProviderSignals
             virtual bool connectRemoteAircraftProviderSignals(
-                std::function<void(const BlackMisc::Aviation::CAircraftSituation &)> situationSlot,
-                std::function<void(const BlackMisc::Aviation::CAircraftParts &)> partsSlot,
-                std::function<void(const BlackMisc::Aviation::CCallsign &)> removedAircraftSlot
+                std::function<void(const BlackMisc::Aviation::CAircraftSituation &)>          addedSituationSlot,
+                std::function<void(const BlackMisc::Aviation::CAircraftParts &)>              addedPartsSlot,
+                std::function<void(const BlackMisc::Aviation::CCallsign &)>                   removedAircraftSlot,
+                std::function<void(const BlackMisc::Simulation::CAirspaceAircraftSnapshot &)> aircraftSnapshotSlot
             ) override;
 
             //! \copydoc IRemoteAircraftProvider::updateAircraftEnabled
@@ -97,6 +101,9 @@ namespace BlackMisc
             //! Added aircraft
             void removedRemoteAircraft(const BlackMisc::Aviation::CCallsign &callsign);
 
+            //! New aircraft snapshot
+            void airspaceAircraftSnapshot(const BlackMisc::Simulation::CAirspaceAircraftSnapshot &snapshot);
+
         private:
             BlackMisc::Simulation::CSimulatedAircraftList m_aircraft;
             BlackMisc::Aviation::CAircraftSituationList m_situations;

src/blackmisc/simulation/simulatedaircraftlist.cpp

@@ -44,6 +44,16 @@ namespace BlackMisc
             return this->findBy(Predicates::MemberValid(&CSimulatedAircraft::getPilot)).transform(Predicates::MemberTransform(&CSimulatedAircraft::getPilot));
         }
 
+        CSimulatedAircraftList CSimulatedAircraftList::findByEnabled(bool enabled) const
+        {
+            return this->findBy(&CSimulatedAircraft::isEnabled, enabled);
+        }
+
+        CSimulatedAircraftList CSimulatedAircraftList::findByVtol(bool vtol) const
+        {
+            return this->findBy(&CSimulatedAircraft::isVtol, vtol);
+        }
+
         CCallsignSet CSimulatedAircraftList::getCallsignsWithSyncronizedParts() const
         {
             CCallsignSet csl;

src/blackmisc/simulation/simulatedaircraftlist.h

@@ -44,6 +44,12 @@ namespace BlackMisc
             //! All pilots (with valid data)
             BlackMisc::Network::CUserList getPilots() const;
 
+            //! Enabled / disabled aircraft
+            CSimulatedAircraftList findByEnabled(bool enabled) const;
+
+            //! VTOL / non VTOL aircraft
+            CSimulatedAircraftList findByVtol(bool vtol) const;
+
             //! Callsigns of aircraft with synchronized parts
             BlackMisc::Aviation::CCallsignSet getCallsignsWithSyncronizedParts() const;