refs #395, turned remote aircraft provider interface into thread safe interfaces

* references gone, situations, parts, aircraft now as threadsafe copy
* read only interface gone (no longer references, so no longer needed)

src/blackcore/airspace_analyzer.cpp

@@ -18,10 +18,10 @@ using namespace BlackMisc::PhysicalQuantities;
 namespace BlackCore
 {
 
-    CAirspaceAnalyzer::CAirspaceAnalyzer(const IOwnAircraftProviderReadOnly *ownAircraftProvider, const IRemoteAircraftProviderReadOnly *remoteAircraftProvider, INetwork *network, QObject *parent) :
+    CAirspaceAnalyzer::CAirspaceAnalyzer(const IOwnAircraftProviderReadOnly *ownAircraftProvider, IRemoteAircraftProvider *remoteAircraftProvider, INetwork *network, QObject *parent) :
         CContinuousWorker(parent, "CAirspaceAnalyzer"),
         COwnAircraftAwareReadOnly(ownAircraftProvider),
-        CRemoteAircraftAwareReadOnly(remoteAircraftProvider)
+        CRemoteAircraftAware(remoteAircraftProvider)
     {
         Q_ASSERT_X(network, Q_FUNC_INFO, "Network object required to connect");
 

src/blackcore/airspace_analyzer.h

@@ -34,7 +34,7 @@ namespace BlackCore
     class CAirspaceAnalyzer :
         public BlackMisc::CContinuousWorker,
         public BlackMisc::Simulation::COwnAircraftAwareReadOnly,
-        public BlackMisc::Simulation::CRemoteAircraftAwareReadOnly
+        public BlackMisc::Simulation::CRemoteAircraftAware
     {
         Q_OBJECT
 
@@ -44,7 +44,7 @@ namespace BlackCore
 
         //! Constructor
         CAirspaceAnalyzer(const BlackMisc::Simulation::IOwnAircraftProviderReadOnly *ownAircraftProvider,
-                          const BlackMisc::Simulation::IRemoteAircraftProviderReadOnly *remoteAircraftProvider,
+                          BlackMisc::Simulation::IRemoteAircraftProvider *remoteAircraftProvider,
                           INetwork *network, QObject *parent);
 
     public slots:

src/blackcore/airspace_monitor.cpp

@@ -60,18 +60,22 @@ namespace BlackCore
         this->connect(this->m_analyzer, &CAirspaceAnalyzer::timeoutAtc, this, &CAirspaceMonitor::ps_atcControllerDisconnected);
     }
 
-    const CSimulatedAircraftList &CAirspaceMonitor::remoteAircraft() const
+    CSimulatedAircraftList CAirspaceMonitor::getAircraftInRange() const
     {
-        // not thread safe, check
+        QReadLocker l(&m_lockAircraft);
-        Q_ASSERT(this->thread() == QThread::currentThread());
         return m_aircraftInRange;
     }
 
-    CSimulatedAircraftList &CAirspaceMonitor::remoteAircraft()
+    CSimulatedAircraft CAirspaceMonitor::getAircraftForCallsign(const CCallsign &callsign) const
     {
-        // not thread safe, check
+        QReadLocker l(&m_lockAircraft);
-        Q_ASSERT(this->thread() == QThread::currentThread());
+        return m_aircraftInRange.findFirstByCallsign(callsign);
-        return m_aircraftInRange;
+    }
+
+    int CAirspaceMonitor::getAircraftInRangeCount() const
+    {
+        QReadLocker l(&m_lockAircraft);
+        return m_aircraftInRange.size();
     }
 
     CAircraftSituationList CAirspaceMonitor::remoteAircraftSituations(const CCallsign &callsign) const
@@ -121,19 +125,20 @@ namespace BlackCore
         std::function<void(const CAircraftParts &)> partsSlot,
         std::function<void(const CCallsign &)> removedAircraftSlot)
     {
-        bool s1 = connect(this->m_network, &INetwork::aircraftPositionUpdate, situationSlot);
+        bool s1 = connect(this, &CAirspaceMonitor::addedAircraftSituation, situationSlot);
         Q_ASSERT(s1);
-        bool s2 = connect(this, &CAirspaceMonitor::addedRemoteAircraftParts, partsSlot);
+        bool s2 = connect(this, &CAirspaceMonitor::addedAircraftParts, partsSlot);
         Q_ASSERT(s2);
-        bool s3 = connect(this, &CAirspaceMonitor::removedRemoteAircraft, removedAircraftSlot);
+        bool s3 = connect(this, &CAirspaceMonitor::removedAircraft, removedAircraftSlot);
         Q_ASSERT(s3);
         return s1 && s2 && s3;
     }
 
     bool CAirspaceMonitor::updateAircraftEnabled(const CCallsign &callsign, bool enabledForRedering, const QString &originator)
     {
-        CPropertyIndexVariantMap vm(CSimulatedAircraft::IndexEnabled, CVariant::fromValue(enabledForRedering));
         Q_UNUSED(originator);
+        CPropertyIndexVariantMap vm(CSimulatedAircraft::IndexEnabled, CVariant::fromValue(enabledForRedering));
+        QWriteLocker l(&m_lockAircraft);
         int c = m_aircraftInRange.applyIfCallsign(callsign, vm);
         return c > 0;
     }
@@ -141,24 +146,37 @@ namespace BlackCore
     bool CAirspaceMonitor::updateAircraftModel(const CCallsign &callsign, const CAircraftModel &model, const QString &originator)
     {
         Q_UNUSED(originator);
-        CSimulatedAircraft aircraft = m_aircraftInRange.findFirstByCallsign(callsign);
+        QWriteLocker l(&m_lockAircraft);
-        if (!aircraft.hasValidCallsign()) { return false; }
+        CPropertyIndexVariantMap vm(CSimulatedAircraft::IndexModel, model.toCVariant());
-
-        aircraft.setModel(model); // this consolidates all common data such as callsign, ICAO ...
-
-        CPropertyIndexVariantMap vm(CSimulatedAircraft::IndexModel, aircraft.getModel().toCVariant());
         int c = m_aircraftInRange.applyIfCallsign(callsign, vm);
         return c > 0;
     }
 
     bool CAirspaceMonitor::updateFastPositionEnabled(const CCallsign &callsign, bool enableFastPositonUpdates, const QString &originator)
     {
-        CPropertyIndexVariantMap vm(CSimulatedAircraft::IndexFastPositionUpdates, CVariant::fromValue(enableFastPositonUpdates));
         Q_UNUSED(originator);
+        CPropertyIndexVariantMap vm(CSimulatedAircraft::IndexFastPositionUpdates, CVariant::fromValue(enableFastPositonUpdates));
+        QWriteLocker l(&m_lockAircraft);
         int c = m_aircraftInRange.applyIfCallsign(callsign, vm);
         return c > 0;
     }
 
+    bool CAirspaceMonitor::updateAircraftRendered(const CCallsign &callsign, bool rendered, const QString &originator)
+    {
+        Q_UNUSED(originator);
+        CPropertyIndexVariantMap vm(CSimulatedAircraft::IndexRendered, CVariant::fromValue(rendered));
+        QWriteLocker l(&m_lockAircraft);
+        int c = m_aircraftInRange.applyIfCallsign(callsign, vm);
+        return c > 0;
+    }
+
+    void CAirspaceMonitor::updateMarkAllAsNotRendered(const QString &originator)
+    {
+        Q_UNUSED(originator);
+        QWriteLocker l(&m_lockAircraft);
+        m_aircraftInRange.markAllAsNotRendered();
+    }
+
     CFlightPlan CAirspaceMonitor::loadFlightPlanFromNetwork(const CCallsign &callsign)
     {
         CFlightPlan plan;
@@ -195,7 +213,7 @@ namespace BlackCore
             CUser user = station.getController();
             users.push_back(user);
         }
-        foreach(CAircraft aircraft, this->m_aircraftInRange)
+        for (const CAircraft &aircraft : this->getAircraftInRange())
         {
             CUser user = aircraft.getPilot();
             users.push_back(user);
@@ -217,7 +235,7 @@ namespace BlackCore
         }
 
         // do aircraft first, this will handle most callsigns
-        foreach(CAircraft aircraft, this->m_aircraftInRange)
+        for (const CAircraft &aircraft : this->getAircraftInRange())
         {
             if (searchList.isEmpty()) break;
             CCallsign callsign = aircraft.getCallsign();
@@ -319,7 +337,7 @@ namespace BlackCore
     {
         if (!this->m_network->isConnected()) return;
 
-        foreach(CAircraft aircraft, this->m_aircraftInRange)
+        for (const CAircraft &aircraft : this->getAircraftInRange())
         {
             const CCallsign cs(aircraft.getCallsign());
             this->m_network->sendFrequencyQuery(cs);
@@ -335,9 +353,8 @@ namespace BlackCore
 
     void CAirspaceMonitor::requestAtisUpdates()
     {
-        if (!this->m_network->isConnected()) return;
+        if (!this->m_network->isConnected()) { return; }
-
+        for (const CAtcStation &station : this->m_atcStationsOnline)
-        foreach(CAtcStation station, this->m_atcStationsOnline)
         {
             this->m_network->sendAtisQuery(station.getCallsign());
         }
@@ -402,7 +419,11 @@ namespace BlackCore
         vm.addValue({ CSimulatedAircraft::IndexClient, CClient::IndexUser, CUser::IndexRealName }, realname);
         vm.addValue({ CSimulatedAircraft::IndexClient, CClient::IndexVoiceCapabilities }, caps);
 
+        // lock block
+        {
+            QWriteLocker l(&m_lockAircraft);
             this->m_aircraftInRange.applyIf(&CAircraft::getCallsign, callsign, vm);
+        }
 
         // Client
         vm = CPropertyIndexVariantMap({CClient::IndexUser, CUser::IndexRealName}, realname);
@@ -428,8 +449,11 @@ namespace BlackCore
 
         // apply same to client in aircraft
         vm.prependIndex(static_cast<int>(CSimulatedAircraft::IndexClient));
+        // lock block
+        {
+            QWriteLocker l(&m_lockAircraft);
             this->m_aircraftInRange.applyIf(&CSimulatedAircraft::getCallsign, callsign, vm);
-
+        }
         if (flags & INetwork::SupportsAircraftConfigs) m_network->sendAircraftConfigQuery(callsign);
     }
 
@@ -447,21 +471,31 @@ namespace BlackCore
             this->m_otherClients.push_back(CClient(callsign));
         }
         this->m_otherClients.applyIf(&CClient::getCallsign, callsign, vm);
+
+        // make index from plain -> to client
         vm.prependIndex(static_cast<int>(CSimulatedAircraft::IndexClient));
-        this->m_aircraftInRange.applyIf(&CSimulatedAircraft::getCallsign, callsign, vm);
+        bool aircraftContainsCallsign;
+        // lock block
+        {
+            QWriteLocker l(&m_lockAircraft);
+            int u = this->m_aircraftInRange.applyIf(&CSimulatedAircraft::getCallsign, callsign, vm);
+            // if update was successful we know we have that callsign, otherwise explicit check
+            aircraftContainsCallsign = (u > 0) || this->m_aircraftInRange.containsCallsign(callsign);
+        }
+        this->sendFsipiCustomPacket(callsign); // response
 
         // ICAO response from custom data
         if (!aircraftDesignator.isEmpty())
         {
             CAircraftIcao icao(aircraftDesignator, combinedAircraftType, airlineIcao, "", ""); // from custom packet
-            if (this->m_aircraftInRange.containsCallsign(callsign))
+            if (aircraftContainsCallsign)
             {
                 // we have that aircraft, set straight away
                 this->ps_icaoCodesReceived(callsign, icao);
             }
             else
             {
-                // store in cache
+                // store in cache, we can retrieve laterxs
                 this->m_icaoCodeCache.insert(callsign, icao);
             }
         }
@@ -505,22 +539,20 @@ namespace BlackCore
     }
 
     void CAirspaceMonitor::removeAllAircraft()
-    {
-        for (CAircraft aircraft : m_aircraftInRange)
-        {
-            const CCallsign cs(aircraft.getCallsign());
-            emit removedRemoteAircraft(cs);
-        }
-
-        // block for lock scope
     {
         QWriteLocker l1(&m_lockParts);
         QWriteLocker l2(&m_lockSituations);
+        QWriteLocker l3(&m_lockAircraft);
+
+        for (const CAircraft &aircraft : m_aircraftInRange)
+        {
+            const CCallsign cs(aircraft.getCallsign());
+            emit removedAircraft(cs);
+        }
+
         m_situationsByCallsign.clear();
         m_partsByCallsign.clear();
         m_aircraftSupportingParts.clear();
-        }
-
         m_aircraftInRange.clear();
         m_flightPlanCache.clear();
         m_icaoCodeCache.clear();
@@ -583,12 +615,18 @@ namespace BlackCore
     void CAirspaceMonitor::ps_sendReadyForModelMatching(const CCallsign &callsign, int trial)
     {
         // some checks for special conditions, e.g. logout -> empty list, but still signals pending
+        // lock block
+        CSimulatedAircraft remoteAircraft;
+        {
+            QReadLocker l(&m_lockAircraft);
             if (!this->m_connected || this->m_aircraftInRange.isEmpty()) { return; }
             if (!this->m_aircraftInRange.containsCallsign(callsign)) { return; }
 
             // build simulated aircraft and crosscheck if all data are available
-        CSimulatedAircraft remoteAircraft(this->m_aircraftInRange.findFirstByCallsign(callsign));
+            remoteAircraft = CSimulatedAircraft(this->m_aircraftInRange.findFirstByCallsign(callsign));
-        Q_ASSERT_X(remoteAircraft.hasValidCallsign(), "ps_sendReadyForModelMatching", "Inavlid callsign");
+            Q_ASSERT_X(remoteAircraft.hasValidCallsign(), Q_FUNC_INFO, "Invalid callsign");
+        }
+
         CClient remoteClient = this->m_otherClients.findFirstByCallsign(callsign);
         remoteAircraft.setClient(remoteClient);
         remoteAircraft.setModel(remoteClient.getAircraftModel());
@@ -761,6 +799,8 @@ namespace BlackCore
         }
         // ICAO code received when aircraft is already removed or not yet ready
         // We add it to cache and use it when aircraft is created
+        {
+            QWriteLocker l(&m_lockAircraft);
             if (!this->m_aircraftInRange.containsCallsign(callsign))
             {
                 this->m_icaoCodeCache.insert(callsign, icaoData);
@@ -771,6 +811,7 @@ namespace BlackCore
             int c = this->m_aircraftInRange.applyIfCallsign(callsign, vm);
             if (c > 0) { ps_sendReadyForModelMatching(callsign, 1); }
         }
+    }
 
     void CAirspaceMonitor::ps_aircraftUpdateReceived(const CAircraftSituation &situation, const CTransponder &transponder)
     {
@@ -782,8 +823,9 @@ namespace BlackCore
 
         // store situation history
         this->storeAircraftSituation(situation);
-        emit this->addedRemoteAircraftSituation(situation);
+        emit this->addedAircraftSituation(situation);
 
+        QWriteLocker l(&m_lockAircraft);
         bool exists = this->m_aircraftInRange.containsCallsign(callsign);
         if (!exists)
         {
@@ -914,11 +956,12 @@ namespace BlackCore
             m_aircraftSupportingParts.remove(callsign);
         }
 
+        QWriteLocker l(&m_lockAircraft);
         bool contains = this->m_aircraftInRange.containsCallsign(callsign);
         if (contains)
         {
             this->m_aircraftInRange.removeByCallsign(callsign);
-            emit this->removedRemoteAircraft(callsign);
+            emit this->removedAircraft(callsign);
         }
     }
 
@@ -928,6 +971,7 @@ namespace BlackCore
 
         // update
         CPropertyIndexVariantMap vm({CAircraft::IndexCom1System, CComSystem::IndexActiveFrequency}, frequency.toCVariant());
+        QWriteLocker l(&m_lockAircraft);
         int changed = this->m_aircraftInRange.applyIf(&CAircraft::getCallsign, callsign, vm, true);
         if (changed > 0) { emit this->changedAircraftInRange(); }
     }
@@ -936,6 +980,7 @@ namespace BlackCore
     {
         Q_ASSERT(BlackCore::isCurrentThreadCreatingThread(this));
 
+        QWriteLocker l(&m_lockAircraft);
         CSimulatedAircraftList list = this->m_aircraftInRange.findByCallsign(callsign);
         // Skip unknown callsigns
         if (list.isEmpty()) { return; }
@@ -963,7 +1008,7 @@ namespace BlackCore
 
         // store part history (parts always absolute)
         this->storeAircraftParts(parts);
-        emit this->addedRemoteAircraftParts(parts);
+        emit this->addedAircraftParts(parts);
 
         // here I expect always a changed value
         this->m_aircraftInRange.setAircraftParts(callsign, parts);

src/blackcore/airspace_monitor.h

@@ -43,36 +43,58 @@ namespace BlackCore
         //! Constructor
         CAirspaceMonitor(QObject *parent, const BlackMisc::Simulation::IOwnAircraftProviderReadOnly *ownAircraft, INetwork *network, CVatsimBookingReader *bookings, CVatsimDataFileReader *dataFile);
 
-        //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraft
+        //! \copydoc IRemoteAircraftProvider::getAircraftInRange
-        virtual const BlackMisc::Simulation::CSimulatedAircraftList &remoteAircraft() const override;
+        //! \ingroup remoteaircraftprovider
+        virtual BlackMisc::Simulation::CSimulatedAircraftList getAircraftInRange() const override;
 
-        //! \copydoc IRemoteAircraftProvider::remoteAircraft
+        //! \copydoc IRemoteAircraftProvider::getAircraftForCallsign
-        virtual BlackMisc::Simulation::CSimulatedAircraftList &remoteAircraft() override;
+        //! \ingroup remoteaircraftprovider
+        virtual BlackMisc::Simulation::CSimulatedAircraft getAircraftForCallsign(const BlackMisc::Aviation::CCallsign &callsign) const override;
+
+        //! \copydoc IRemoteAircraftProvider::getAircraftInRangeCount
+        //! \ingroup remoteaircraftprovider
+        virtual int getAircraftInRangeCount() const override;
 
         //! \copydoc IRemoteAircraftProvider::remoteAircraftSituations
+        //! \ingroup remoteaircraftprovider
         virtual BlackMisc::Aviation::CAircraftSituationList remoteAircraftSituations(const BlackMisc::Aviation::CCallsign &callsign) const override;
 
         //! \copydoc IRemoteAircraftProvider::remoteAircraftSituationsCount
+        //! \ingroup remoteaircraftprovider
         virtual int remoteAircraftSituationsCount(const BlackMisc::Aviation::CCallsign &callsign) const override;
 
         //! \copydoc IRemoteAircraftProvider::remoteAircraftParts
+        //! \ingroup remoteaircraftprovider
         virtual BlackMisc::Aviation::CAircraftPartsList remoteAircraftParts(const BlackMisc::Aviation::CCallsign &callsign, qint64 cutoffTimeValuesBefore = -1) const override;
 
-        //! \copydoc IRemoteAircraftProviderReadOnly::isRemoteAircraftSupportingParts
+        //! \copydoc IRemoteAircraftProvider::isRemoteAircraftSupportingParts
+        //! \ingroup remoteaircraftprovider
         virtual bool isRemoteAircraftSupportingParts(const BlackMisc::Aviation::CCallsign &callsign) const override;
 
-        //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraftSupportingParts
+        //! \copydoc IRemoteAircraftProvider::remoteAircraftSupportingParts
+        //! \ingroup remoteaircraftprovider
         virtual BlackMisc::Aviation::CCallsignSet remoteAircraftSupportingParts() const override;
 
         //! \copydoc IRemoteAircraftProvider::updateAircraftEnabled
+        //! \ingroup remoteaircraftprovider
         virtual bool updateAircraftEnabled(const BlackMisc::Aviation::CCallsign &callsign, bool enabledForRedering, const QString &originator) override;
 
         //! \copydoc IRemoteAircraftProvider::updateAircraftModel
+        //! \ingroup remoteaircraftprovider
         virtual bool updateAircraftModel(const BlackMisc::Aviation::CCallsign &callsign, const BlackMisc::Simulation::CAircraftModel &model, const QString &originator) override;
 
         //! \copydoc IRemoteAircraftProvider::updateFastPositionEnabled
+        //! \ingroup remoteaircraftprovider
         virtual bool updateFastPositionEnabled(const BlackMisc::Aviation::CCallsign &callsign, bool enableFastPositonUpdates, const QString &originator) override;
 
+        //! \copydoc IRemoteAircraftProvider::updateAircraftRendered
+        //! \ingroup remoteaircraftprovider
+        virtual bool updateAircraftRendered(const BlackMisc::Aviation::CCallsign &callsign, bool rendered, const QString &originator) override;
+
+        //! \copydoc IRemoteAircraftProvider::updateMarkAllAsNotRendered
+        //! \ingroup remoteaircraftprovider
+        virtual void updateMarkAllAsNotRendered(const QString &originator) override;
+
         //! Returns the list of users we know about
         BlackMisc::Network::CUserList getUsers() const;
 
@@ -119,8 +141,8 @@ namespace BlackCore
         //! Test injected aircraft parts
         void testAddAircraftParts(const BlackMisc::Aviation::CAircraftParts &parts, bool incremental);
 
-        //! \copydoc IRemoteAircraftProviderReadOnly::connectSignals
+        //! \copydoc IRemoteAircraftProvider::connectSignals
-        //! \copydoc IRemoteAircraftProviderReadOnly::connectSignals
+        //! \copydoc IRemoteAircraftProvider::connectSignals
         virtual bool connectRemoteAircraftProviderSignals(
             std::function<void(const BlackMisc::Aviation::CAircraftSituation &)> situationSlot,
             std::function<void(const BlackMisc::Aviation::CAircraftParts &)> partsSlot,
@@ -138,17 +160,6 @@ namespace BlackCore
 
     signals:
 
-        //--- signals for the provider, work locally only (not in DBus)
-
-        //! \copydoc IRemoteAircraftProviderReadOnly::addedRemoteAircraftPart
-        void addedRemoteAircraftSituation(const BlackMisc::Aviation::CAircraftSituation &situation);
-
-        //! \copydoc IRemoteAircraftProviderReadOnly::addedRemoteAircraftPart
-        void addedRemoteAircraftParts(const BlackMisc::Aviation::CAircraftParts &parts);
-
-        //! \copydoc IRemoteAircraftProviderReadOnly::removedAircraft
-        void removedRemoteAircraft(const BlackMisc::Aviation::CCallsign &callsign);
-
         //--- DBus / local signals
 
         //! Online ATC stations were changed
@@ -166,9 +177,18 @@ namespace BlackCore
         //! A new aircraft appeared
         void addedAircraft(const BlackMisc::Simulation::CSimulatedAircraft &remoteAircraft);
 
+        //! Parts added
+        void addedAircraftParts(const BlackMisc::Aviation::CAircraftParts &parts);
+
+        //! Situation added
+        void addedAircraftSituation(const BlackMisc::Aviation::CAircraftSituation &situation);
+
         //! Read for model matching
         void readyForModelMatching(const BlackMisc::Simulation::CSimulatedAircraft &remoteAircraft);
 
+        //! An aircraft disappeared
+        void removedAircraft(const BlackMisc::Aviation::CCallsign &callsign);
+
     private:
         BlackMisc::Aviation::CAtcStationList m_atcStationsOnline;
         BlackMisc::Aviation::CAtcStationList m_atcStationsBooked;
@@ -196,7 +216,7 @@ namespace BlackCore
         // locks
         mutable QReadWriteLock m_lockSituations; //!< lock for situations
         mutable QReadWriteLock m_lockParts;      //!< lock for parts
-
+        mutable QReadWriteLock m_lockAircraft;   //!< lock aircraft
 
         // TODO FIXME (MS) should be in INetwork
         void sendFsipiCustomPacket(const BlackMisc::Aviation::CCallsign &recipientCallsign) const;

src/blackcore/context_network.h

@@ -121,13 +121,11 @@ namespace BlackCore
         //! Bookings read
         void vatsimBookingsRead();
 
-        /*!
+        //! Connection status changed
-         * Connection status changed
+        //! \param from  old status
-         * \param from  old status
+        //! \param to    new status
-         * \param to    new status
+        //! \remarks If I use the enum, adaptor / interface are not created correctly
-         * \remarks If I use the enum, adaptor / interface are not created correctly
+        //! \see INetwork::ConnectionStatus
-         * \see INetwork::ConnectionStatus
-         */
         void connectionStatusChanged(int from, int to);
 
         //! Text messages received (also private chat messages, rfaio channel messages)
@@ -156,6 +154,9 @@ namespace BlackCore
         //! Aircraft for given callsign
         virtual BlackMisc::Simulation::CSimulatedAircraft getAircraftForCallsign(const BlackMisc::Aviation::CCallsign &callsign) const = 0;
 
+        //! Aircraft count
+        virtual int getAircraftInRangeCount() const = 0;
+
         //! Online station for callsign
         virtual BlackMisc::Aviation::CAtcStation getOnlineStationForCallsign(const BlackMisc::Aviation::CCallsign &callsign) const = 0;
 
@@ -192,17 +193,13 @@ namespace BlackCore
         //! Callsigns enabled for fast position updates
         virtual BlackMisc::Aviation::CCallsignSet getFastPositionEnabledCallsigns() = 0;
 
-        /*!
+        //! Connect to Network
-         * Connect to Network
+        //! \return messages gererated during connecting
-         * \return messages gererated during connecting
+        //! \see INetwork::LoginMode
-         * \see INetwork::LoginMode
-         */
         virtual BlackMisc::CStatusMessage connectToNetwork(const BlackMisc::Network::CServer &server, uint loginMode) = 0;
 
-        /*!
+        //! Disconnect from network
-         * Disconnect from network
+        //! \return messages generated during disconnecting
-         * \return messages generated during disconnecting
-         */
         virtual BlackMisc::CStatusMessage disconnectFromNetwork() = 0;
 
         //! Network connected?

src/blackcore/context_network_empty.h

@@ -66,6 +66,13 @@ namespace BlackCore
             return BlackMisc::Simulation::CSimulatedAircraft();
         }
 
+        //! \copydoc IRemoteAircraftProvider::getAircraftInRangeCount
+        virtual int getAircraftInRangeCount() const override
+        {
+            logEmptyContextWarning(Q_FUNC_INFO);
+            return 0;
+        }
+
         //! \copydoc IContextNetwork::getOnlineStationForCallsign
         virtual BlackMisc::Aviation::CAtcStation getOnlineStationForCallsign(const BlackMisc::Aviation::CCallsign &callsign) const override
         {

src/blackcore/context_network_impl.cpp

@@ -78,13 +78,16 @@ namespace BlackCore
         connect(this->m_airspace, &CAirspaceMonitor::changedAtcStationsBooked, this, &CContextNetwork::changedAtcStationsBooked);
         connect(this->m_airspace, &CAirspaceMonitor::changedAtcStationOnlineConnectionStatus, this, &CContextNetwork::changedAtcStationOnlineConnectionStatus);
         connect(this->m_airspace, &CAirspaceMonitor::changedAircraftInRange, this, &CContextNetwork::changedAircraftInRange);
-        connect(this->m_airspace, &CAirspaceMonitor::removedRemoteAircraft, this, &IContextNetwork::removedAircraft); // DBus
+        connect(this->m_airspace, &CAirspaceMonitor::removedAircraft, this, &IContextNetwork::removedAircraft); // DBus
         connect(this->m_airspace, &CAirspaceMonitor::readyForModelMatching, this, &CContextNetwork::readyForModelMatching);
         connect(this->m_airspace, &CAirspaceMonitor::addedAircraft, this, &CContextNetwork::addedAircraft);
+    }
 
-        // remote provider, local only
+    CContextNetwork *CContextNetwork::registerWithDBus(CDBusServer *server)
-        connect(this->m_airspace, &CAirspaceMonitor::removedRemoteAircraft, this, &CContextNetwork::removedRemoteAircraft); // Local
+    {
-        connect(this->m_airspace, &CAirspaceMonitor::addedRemoteAircraftParts, this, &CContextNetwork::addedRemoteAircraftParts);
+        if (!server || this->m_mode != CRuntimeConfig::LocalInDbusServer) return this;
+        server->addObject(IContextNetwork::ObjectPath(), this);
+        return this;
     }
 
     CContextNetwork::~CContextNetwork()
@@ -92,18 +95,6 @@ namespace BlackCore
         this->gracefulShutdown();
     }
 
-    const CSimulatedAircraftList &CContextNetwork::remoteAircraft() const
-    {
-        Q_ASSERT(this->m_airspace);
-        return m_airspace->remoteAircraft();
-    }
-
-    CSimulatedAircraftList &CContextNetwork::remoteAircraft()
-    {
-        Q_ASSERT(this->m_airspace);
-        return m_airspace->remoteAircraft();
-    }
-
     CAircraftSituationList CContextNetwork::remoteAircraftSituations(const CCallsign &callsign) const
     {
         Q_ASSERT(this->m_airspace);
@@ -480,13 +471,19 @@ namespace BlackCore
     CSimulatedAircraftList CContextNetwork::getAircraftInRange() const
     {
         if (this->isDebugEnabled()) { CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO; }
-        return this->m_airspace->remoteAircraft();
+        return this->m_airspace->getAircraftInRange();
+    }
+
+    int CContextNetwork::getAircraftInRangeCount() const
+    {
+        if (this->isDebugEnabled()) { CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO; }
+        return this->m_airspace->getAircraftInRangeCount();
     }
 
     CSimulatedAircraft CContextNetwork::getAircraftForCallsign(const CCallsign &callsign) const
     {
         if (this->isDebugEnabled()) { BlackMisc::CLogMessage(this, BlackMisc::CLogCategory::contextSlot()).debug() << Q_FUNC_INFO << callsign; }
-        return this->m_airspace->remoteAircraft().findFirstByCallsign(callsign);
+        return this->m_airspace->getAircraftInRange().findFirstByCallsign(callsign);
     }
 
     CAtcStation CContextNetwork::getOnlineStationForCallsign(const CCallsign &callsign) const
@@ -527,7 +524,7 @@ namespace BlackCore
         bool c = this->m_airspace->updateAircraftEnabled(callsign, enabledForRedering, originator);
         if (c)
         {
-            CSimulatedAircraft aircraft(this->remoteAircraft().findFirstByCallsign(callsign));
+            CSimulatedAircraft aircraft(this->getAircraftForCallsign(callsign));
             emit this->changedRemoteAircraftEnabled(aircraft, originator);
         }
         return c;
@@ -539,7 +536,7 @@ namespace BlackCore
         bool c = this->m_airspace->updateAircraftModel(callsign, model, originator);
         if (c)
         {
-            CSimulatedAircraft aircraft(this->remoteAircraft().findFirstByCallsign(callsign));
+            CSimulatedAircraft aircraft(this->getAircraftForCallsign(callsign));
             emit this->changedRemoteAircraftModel(aircraft, originator);
         }
         return c;
@@ -551,13 +548,26 @@ namespace BlackCore
         bool c = this->m_airspace->updateFastPositionEnabled(callsign, enableFastPositonUpdates, originator);
         if (c)
         {
-            CSimulatedAircraft aircraft(this->remoteAircraft().findFirstByCallsign(callsign));
+            CSimulatedAircraft aircraft(this->getAircraftForCallsign(callsign));
             CLogMessage(this).info("Callsign %1 sets fast positions ") << aircraft.getCallsign() << BlackMisc::boolToOnOff(aircraft.fastPositionUpdates());
             emit this->changedFastPositionUpdates(aircraft, originator);
         }
         return c;
     }
 
+    bool CContextNetwork::updateAircraftRendered(const CCallsign &callsign, bool rendered, const QString &originator)
+    {
+        if (this->isDebugEnabled()) { CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO << callsign << rendered << originator; }
+        bool c = this->m_airspace->updateAircraftRendered(callsign, rendered, originator);
+        return c;
+    }
+
+    void CContextNetwork::updateMarkAllAsNotRendered(const QString &originator)
+    {
+        if (this->isDebugEnabled()) { CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO << originator; }
+        this->m_airspace->updateMarkAllAsNotRendered(originator);
+    }
+
     bool CContextNetwork::isFastPositionSendingEnabled() const
     {
         if (this->isDebugEnabled()) { CLogMessage(this, CLogCategory::contextSlot()).debug() << Q_FUNC_INFO; }

src/blackcore/context_network_impl.h

@@ -51,43 +51,55 @@ namespace BlackCore
         //! Destructor
         virtual ~CContextNetwork();
 
-        //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraft
+        //! \copydoc IRemoteAircraftProvider::remoteAircraftSituations
-        virtual const BlackMisc::Simulation::CSimulatedAircraftList &remoteAircraft() const override;
+        //! \ingroup remoteaircraftprovider
-
-        //! \copydoc IRenderedAircraftProvider::remoteAircraft
-        virtual BlackMisc::Simulation::CSimulatedAircraftList &remoteAircraft() override;
-
-        //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraftSituations
         virtual BlackMisc::Aviation::CAircraftSituationList remoteAircraftSituations(const BlackMisc::Aviation::CCallsign &callsign) const override;
 
         //! \copydoc IRemoteAircraftProvider::remoteAircraftSituationsCount
+        //! \ingroup remoteaircraftprovider
         virtual int remoteAircraftSituationsCount(const BlackMisc::Aviation::CCallsign &callsign) const override;
 
-        //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraftParts
+        //! \copydoc IRemoteAircraftProvider::remoteAircraftParts
+        //! \ingroup remoteaircraftprovider
         virtual BlackMisc::Aviation::CAircraftPartsList remoteAircraftParts(const BlackMisc::Aviation::CCallsign &callsign, qint64 cutoffTimeBefore = -1) const override;
 
-        //! \copydoc IRemoteAircraftProviderReadOnly::isRemoteAircraftSupportingParts
+        //! \copydoc IRemoteAircraftProvider::isRemoteAircraftSupportingParts
+        //! \ingroup remoteaircraftprovider
         virtual bool isRemoteAircraftSupportingParts(const BlackMisc::Aviation::CCallsign &callsign) const;
 
-        //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraftSupportingParts
+        //! \copydoc IRemoteAircraftProvider::remoteAircraftSupportingParts
+        //! \ingroup remoteaircraftprovider
         virtual BlackMisc::Aviation::CCallsignSet remoteAircraftSupportingParts() const override;
 
-        //! \copydoc IRemoteAircraftProviderReadOnly::connectSignals
+        //! \copydoc IRemoteAircraftProvider::connectSignals
+        //! \ingroup remoteaircraftprovider
         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
         ) override;
 
-    signals:
+        //! \copydoc IRemoteAircraftProvider::updateAircraftRendered
-        //! \copydoc IRemoteAircraftProviderReadOnly::addedRemoteAircraftPart
+        //! \ingroup remoteaircraftprovider
-        void addedRemoteAircraftParts(const BlackMisc::Aviation::CAircraftParts &parts);
+        virtual bool updateAircraftRendered(const BlackMisc::Aviation::CCallsign &callsign, bool rendered, const QString &originator) override;
 
-        //! \copydoc IRemoteAircraftProviderReadOnly::removedAircraft
+        //! \copydoc IRemoteAircraftProvider::updateMarkAllAsNotRendered
-        //! \sa IContextNetwork::removedAircraft() which is the equivalent when using IContextNetwork
+        //! \ingroup remoteaircraftprovider
-        void removedRemoteAircraft(const BlackMisc::Aviation::CCallsign &callsign);
+        virtual void updateMarkAllAsNotRendered(const QString &originator) override;
 
     public slots:
+        //! \copydoc IContextNetwork::updateAircraftEnabled
+        //! \ingroup remoteaircraftprovider
+        virtual bool updateAircraftEnabled(const BlackMisc::Aviation::CCallsign &callsign, bool enabledForRedering, const QString &originator) override;
+
+        //! \copydoc IContextNetwork::updateAircraftModel
+        //! \ingroup remoteaircraftprovider
+        virtual bool updateAircraftModel(const BlackMisc::Aviation::CCallsign &callsign, const BlackMisc::Simulation::CAircraftModel &model, const QString &originator) override;
+
+        //! \copydoc IContextNetwork::updateFastPositionEnabled
+        //! \ingroup remoteaircraftprovider
+        virtual bool updateFastPositionEnabled(const BlackMisc::Aviation::CCallsign &callsign, bool enableFastPositonUpdates, const QString &originator) override;
+
         //! \copydoc IContextNetwork::readAtcBookingsFromSource()
         virtual void readAtcBookingsFromSource() const override;
 
@@ -97,10 +109,16 @@ namespace BlackCore
         //! \copydoc IContextNetwork::getAtcStationsBooked()
         virtual BlackMisc::Aviation::CAtcStationList getAtcStationsBooked() const override;
 
-        //! \copydoc IContextNetwork::getAircraftInRange()
+        //! \copydoc IContextNetwork::getAircraftInRange
+        //! \ingroup remoteaircraftprovider
         virtual BlackMisc::Simulation::CSimulatedAircraftList getAircraftInRange() const override;
 
+        //! \copydoc IRemoteAircraftProvider::getAircraftInRangeCount
+        //! \ingroup remoteaircraftprovider
+        virtual int getAircraftInRangeCount() const override;
+
         //! \copydoc IContextNetwork::getAircraftForCallsign
+        //! \ingroup remoteaircraftprovider
         virtual BlackMisc::Simulation::CSimulatedAircraft getAircraftForCallsign(const BlackMisc::Aviation::CCallsign &callsign) const override;
 
         //! \copydoc IContextNetwork::getOnlineStationForCallsign
@@ -115,14 +133,12 @@ namespace BlackCore
         //! \copydoc IContextNetwork::isConnected()
         virtual bool isConnected() const override;
 
-        /*!
+        //! In transition state, e.g. connecting, disconnecting.
-         * In transition state, e.g. connecting, disconnecting.
+        //! \details In such a state it is advisable to wait until an end state (connected/disconnected) is reached
-         * \details In such a state it is advisable to wait until an end state (connected/disconnected) is reached
+        //! \remarks Intentionally only running locally, not in interface
-         * \remarks Intentionally only running locally, not in interface
-         */
         bool isPendingConnection() const;
 
-        //! \addtogroup commandline
+        //! \ingroup commandline
         //! @{
         //! <pre>
         //! .m  .msg   message text
@@ -176,15 +192,6 @@ namespace BlackCore
         //! \copydoc IContextNetwork::requestAtisUpdates
         virtual void requestAtisUpdates() override;
 
-        //! \copydoc IContextNetwork::updateAircraftEnabled
-        virtual bool updateAircraftEnabled(const BlackMisc::Aviation::CCallsign &callsign, bool enabledForRedering, const QString &originator) override;
-
-        //! \copydoc IContextNetwork::updateAircraftModel
-        virtual bool updateAircraftModel(const BlackMisc::Aviation::CCallsign &callsign, const BlackMisc::Simulation::CAircraftModel &model, const QString &originator) override;
-
-        //! \copydoc IContextNetwork::updateFastPositionEnabled
-        virtual bool updateFastPositionEnabled(const BlackMisc::Aviation::CCallsign &callsign, bool enableFastPositonUpdates, const QString &originator) override;
-
         //! \copydoc IContextNetwork::isFastPositionSendingEnabled
         virtual bool isFastPositionSendingEnabled() const override;
 
@@ -211,12 +218,7 @@ namespace BlackCore
         CContextNetwork(CRuntimeConfig::ContextMode, CRuntime *runtime);
 
         //! Register myself in DBus
-        CContextNetwork *registerWithDBus(CDBusServer *server)
+        CContextNetwork *registerWithDBus(CDBusServer *server);
-        {
-            if (!server || this->m_mode != CRuntimeConfig::LocalInDbusServer) return this;
-            server->addObject(IContextNetwork::ObjectPath(), this);
-            return this;
-        }
 
     private:
         CAirspaceMonitor    *m_airspace = nullptr;

src/blackcore/context_network_proxy.cpp

@@ -82,7 +82,7 @@ namespace BlackCore
                                "changedRemoteAircraftEnabled", this, SIGNAL(changedRemoteAircraftEnabled(BlackMisc::Simulation::CSimulatedAircraft, QString)));
         Q_ASSERT(s);
         s = connection.connect(serviceName, IContextNetwork::ObjectPath(), IContextNetwork::InterfaceName(),
-                               "changedFastPositionUpdates", this, SIGNAL(changedFastPositionUpdates(BlackMisc::Simulation::CSimulatedAircraft,QString)));
+                               "changedFastPositionUpdates", this, SIGNAL(changedFastPositionUpdates(BlackMisc::Simulation::CSimulatedAircraft, QString)));
         Q_ASSERT(s);
         s = connection.connect(serviceName, IContextNetwork::ObjectPath(), IContextNetwork::InterfaceName(),
                                "addedAircraft", this, SIGNAL(addedAircraft(BlackMisc::Simulation::CSimulatedAircraft)));
@@ -113,6 +113,11 @@ namespace BlackCore
         return this->m_dBusInterface->callDBusRet<BlackMisc::Simulation::CSimulatedAircraftList>(QLatin1Literal("getAircraftInRange"));
     }
 
+    int CContextNetworkProxy::getAircraftInRangeCount() const
+    {
+        return this->m_dBusInterface->callDBusRet<int>(QLatin1Literal("getAircraftInRangeCount"));
+    }
+
     Simulation::CSimulatedAircraft CContextNetworkProxy::getAircraftForCallsign(const CCallsign &callsign) const
     {
         return this->m_dBusInterface->callDBusRet<BlackMisc::Simulation::CSimulatedAircraft>(QLatin1Literal("getAircraftForCallsign"), callsign);

src/blackcore/context_network_proxy.h

@@ -66,6 +66,9 @@ namespace BlackCore
         //! \copydoc IContextNetwork::getAircraftInRange()
         virtual BlackMisc::Simulation::CSimulatedAircraftList getAircraftInRange() const override;
 
+        //! \copydoc IContextNetwork::getAircraftInRangeCount
+        virtual int getAircraftInRangeCount() const override;
+
         //! \copydoc IContextNetwork::getAircraftForCallsign
         virtual BlackMisc::Simulation::CSimulatedAircraft getAircraftForCallsign(const BlackMisc::Aviation::CCallsign &callsign) const override;
 

src/blackcore/interpolator.cpp

@@ -19,9 +19,9 @@ using namespace BlackMisc::Simulation;
 namespace BlackCore
 {
 
-    IInterpolator::IInterpolator(IRemoteAircraftProviderReadOnly *provider, const QString &workerName, QObject *parent) :
+    IInterpolator::IInterpolator(IRemoteAircraftProvider *provider, const QString &workerName, QObject *parent) :
         CContinuousWorker(parent, workerName),
-        CRemoteAircraftAwareReadOnly(provider)
+        CRemoteAircraftAware(provider)
     {
         Q_ASSERT_X(provider, Q_FUNC_INFO, "missing provider");
     }

src/blackcore/interpolator.h

@@ -24,7 +24,7 @@ namespace BlackCore
     //! Interpolator, calculation inbetween positions
     class BLACKCORE_EXPORT IInterpolator :
         public BlackMisc::CContinuousWorker,
-        public BlackMisc::Simulation::CRemoteAircraftAwareReadOnly
+        public BlackMisc::Simulation::CRemoteAircraftAware
     {
         Q_OBJECT
 
@@ -77,7 +77,7 @@ namespace BlackCore
 
     protected:
         //! Constructor
-        IInterpolator(BlackMisc::Simulation::IRemoteAircraftProviderReadOnly *provider, const QString &workerName, QObject *parent = nullptr);
+        IInterpolator(BlackMisc::Simulation::IRemoteAircraftProvider *provider, const QString &workerName, QObject *parent = nullptr);
 
         bool m_withDebugMsg = false;  //!< allows to disable debug messages
     };

src/blackcore/interpolator_linear.h

@@ -26,7 +26,7 @@ namespace BlackCore
     {
     public:
         //! Constructor
-        CInterpolatorLinear(BlackMisc::Simulation::IRemoteAircraftProviderReadOnly *provider, QObject *parent = nullptr) :
+        CInterpolatorLinear(BlackMisc::Simulation::IRemoteAircraftProvider *provider, QObject *parent = nullptr) :
             IInterpolator(provider, "CInterpolatorLinear", parent)
         {}
 

src/blackcore/simulator.cpp

@@ -90,8 +90,7 @@ namespace BlackCore
         if (!isMaxAircraftRestricted()) { return; }
         if (!isRenderingEnabled()) { return; }
 
-        //! \todo Simulator, why is there no difference on CSequence?
+        CSimulatedAircraftList newAircraftInRange(getAircraftInRange().getClosestObjects(getMaxRenderedAircraft()));
-        CSimulatedAircraftList newAircraftInRange(remoteAircraft().getClosestObjects(getMaxRenderedAircraft()));
         CCallsignSet newAircraftCallsigns(newAircraftInRange.getCallsigns());
         CCallsignSet toBeRemovedCallsigns(m_callsignsToBeRendered.difference(newAircraftCallsigns));
         CCallsignSet toBeAddedCallsigns(newAircraftCallsigns.difference(m_callsignsToBeRendered));
@@ -108,7 +107,7 @@ namespace BlackCore
 
     void CSimulatorCommon::resetAircraftFromBacked(const CCallsign &callsign)
     {
-        CSimulatedAircraft aircraft(this->remoteAircraft().findFirstByCallsign(callsign));
+        CSimulatedAircraft aircraft(this->getAircraftForCallsign(callsign));
         bool enabled = aircraft.isEnabled();
         if (enabled)
         {

src/blackmisc/propertyindexvariantmap.cpp

@@ -13,39 +13,24 @@
 
 namespace BlackMisc
 {
-    /*
-     * Constructor
-     */
     CPropertyIndexVariantMap::CPropertyIndexVariantMap(bool wildcard) : m_wildcard(wildcard) {}
 
-    /*
-     * Constructor single value
-     */
     CPropertyIndexVariantMap::CPropertyIndexVariantMap(const CPropertyIndex &index, const CVariant &value)
         : m_wildcard(false)
     {
         this->addValue(index, value);
     }
 
-    /*
-     * ==
-     */
     bool operator ==(const CPropertyIndexVariantMap &a, const CPropertyIndexVariantMap &b)
     {
         return a.m_wildcard == b.m_wildcard && a.m_values == b.m_values;
     }
 
-    /*
-     * !=
-     */
     bool operator !=(const CPropertyIndexVariantMap &a, const CPropertyIndexVariantMap &b)
     {
         return !(b == a);
     }
 
-    /*
-     * Compare with CVariant
-     */
     bool operator==(const CPropertyIndexVariantMap &indexMap, const CVariant &variant)
     {
         if (indexMap.isEmpty()) return indexMap.isWildcard();
@@ -60,33 +45,21 @@ namespace BlackMisc
         return true;
     }
 
-    /*
-     * Compare with CVariant
-     */
     bool operator!=(const CPropertyIndexVariantMap &indexMap, const CVariant &variant)
     {
         return !(indexMap == variant);
     }
 
-    /*
-     * Compare with CVariant
-     */
     bool operator==(const CVariant &variant, const CPropertyIndexVariantMap &valueMap)
     {
         return valueMap == variant;
     }
 
-    /*
-     * Compare with CVariant
-     */
     bool operator!=(const CVariant &variant, const CPropertyIndexVariantMap &valueMap)
     {
         return !(valueMap == variant);
     }
 
-    /*
-     * Convert to string
-     */
     QString CPropertyIndexVariantMap::convertToQString(bool i18n) const
     {
         if (this->isEmpty()) return QString("{wildcard: %1}").arg(this->m_wildcard ? "true" : "false");
@@ -109,18 +82,17 @@ namespace BlackMisc
         return s;
     }
 
-    /*
+    int CPropertyIndexVariantMap::getMetaTypeId() const
-     * Marshall to DBus
+    {
-     */
+        return qMetaTypeId<CPropertyIndexVariantMap>();
+    }
+
     void CPropertyIndexVariantMap::marshallToDbus(QDBusArgument &argument) const
     {
         argument << this->m_values.keys();
         argument << this->m_values.values();
     }
 
-    /*
-     * Unmarshall from DBus
-     */
     void CPropertyIndexVariantMap::unmarshallFromDbus(const QDBusArgument &argument)
     {
         QList<CPropertyIndex> indexes;
@@ -137,17 +109,11 @@ namespace BlackMisc
         this->m_values.swap(newMap);
     }
 
-    /*
-     * Add value
-     */
     void CPropertyIndexVariantMap::addValue(const CPropertyIndex &index, const CVariant &value)
     {
         this->m_values.insert(index, value);
     }
 
-    /*
-     * Add string by literal
-     */
     void CPropertyIndexVariantMap::addValue(const CPropertyIndex &index, const char *str)
     {
         this->addValue(index, QString(str));
@@ -165,23 +131,23 @@ namespace BlackMisc
         this->m_values = newMap;
     }
 
-    /*
-     * Indexes
-     */
     CPropertyIndexList CPropertyIndexVariantMap::indexes() const
     {
         return CPropertyIndexList::fromImpl(this->m_values.keys());
     }
 
-    /*
+    void CPropertyIndexVariantMap::registerMetadata()
-     * Hash
+    {
-     */
+        qRegisterMetaType<CPropertyIndexVariantMap>();
+        qDBusRegisterMetaType<CPropertyIndexVariantMap>();
+    }
+
     uint CPropertyIndexVariantMap::getValueHash() const
     {
         // there is no hash for map, so I use this workaround here
         const QString s = this->toQString(false);
         QList<uint> h;
         h << qHash(s);
-        return BlackMisc::calculateHash(h, "CIndexVariantMap");
+        return BlackMisc::calculateHash(h, "CPropertyIndexVariantMap");
     }
 } // namespace

src/blackmisc/simulation/remoteaircraftprovider.cpp

@@ -16,52 +16,22 @@ namespace BlackMisc
     namespace Simulation
     {
 
-        const CSimulatedAircraftList &CRemoteAircraftAwareReadOnly::remoteAircraft() const
+        CSimulatedAircraftList CRemoteAircraftAware::getAircraftInRange() const
         {
             Q_ASSERT_X(this->m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return this->m_remoteAircraftProvider->remoteAircraft();
+            return this->m_remoteAircraftProvider->getAircraftInRange();
         }
 
-        Aviation::CAircraftSituationList CRemoteAircraftAwareReadOnly::remoteAircraftSituations(const BlackMisc::Aviation::CCallsign &callsign) const
+        int CRemoteAircraftAware::getAircraftInRangeCount() const
         {
             Q_ASSERT_X(this->m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return this->m_remoteAircraftProvider->remoteAircraftSituations(callsign);
+            return this->m_remoteAircraftProvider->getAircraftInRangeCount();
         }
 
-        int CRemoteAircraftAwareReadOnly::remoteAircraftSituationsCount(const CCallsign &callsign) const
+        CSimulatedAircraft CRemoteAircraftAware::getAircraftForCallsign(const CCallsign &callsign) const
         {
             Q_ASSERT_X(this->m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return this->m_remoteAircraftProvider->remoteAircraftSituationsCount(callsign);
+            return this->m_remoteAircraftProvider->getAircraftForCallsign(callsign);
-        }
-
-        CAircraftPartsList CRemoteAircraftAwareReadOnly::remoteAircraftParts(const BlackMisc::Aviation::CCallsign &callsign, qint64 cutoffTimeBefore) const
-        {
-            Q_ASSERT_X(this->m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return this->m_remoteAircraftProvider->remoteAircraftParts(callsign, cutoffTimeBefore);
-        }
-
-        CCallsignSet CRemoteAircraftAwareReadOnly::remoteAircraftSupportingParts() const
-        {
-            Q_ASSERT_X(this->m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return this->m_remoteAircraftProvider->remoteAircraftSupportingParts();
-        }
-
-        bool CRemoteAircraftAwareReadOnly::isRemoteAircraftSupportingParts(const CCallsign &callsign) const
-        {
-            Q_ASSERT_X(this->m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return this->m_remoteAircraftProvider->isRemoteAircraftSupportingParts(callsign);
-        }
-
-        const CSimulatedAircraftList &CRemoteAircraftAware::remoteAircraft() const
-        {
-            Q_ASSERT_X(this->m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return this->m_remoteAircraftProvider->remoteAircraft();
-        }
-
-        CSimulatedAircraftList &CRemoteAircraftAware::remoteAircraft()
-        {
-            Q_ASSERT_X(this->m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return this->m_remoteAircraftProvider->remoteAircraft();
         }
 
         CAircraftSituationList CRemoteAircraftAware::remoteAircraftSituations(const BlackMisc::Aviation::CCallsign &callsign) const
@@ -70,10 +40,10 @@ namespace BlackMisc
             return this->m_remoteAircraftProvider->remoteAircraftSituations(callsign);
         }
 
-        CAircraftPartsList CRemoteAircraftAware::remoteAircraftParts(const BlackMisc::Aviation::CCallsign &callsign) const
+        CAircraftPartsList CRemoteAircraftAware::remoteAircraftParts(const CCallsign &callsign, qint64 cutoffTimeBefore) const
         {
             Q_ASSERT_X(this->m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return this->m_remoteAircraftProvider->remoteAircraftParts(callsign);
+            return this->m_remoteAircraftProvider->remoteAircraftParts(callsign, cutoffTimeBefore);
         }
 
         CCallsignSet CRemoteAircraftAware::remoteAircraftSupportingParts() const
@@ -88,19 +58,31 @@ namespace BlackMisc
             return this->m_remoteAircraftProvider->remoteAircraftSituationsCount(callsign);
         }
 
-        bool CRemoteAircraftAware::providerUpdateAircraftModel(const Aviation::CCallsign &callsign, const CAircraftModel &model, const QString &originator)
+        bool CRemoteAircraftAware::updateAircraftModel(const Aviation::CCallsign &callsign, const CAircraftModel &model, const QString &originator)
         {
             Q_ASSERT_X(this->m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
             return this->m_remoteAircraftProvider->updateAircraftModel(callsign, model, originator);
         }
 
+        bool CRemoteAircraftAware::updateAircraftRendered(const CCallsign &callsign, bool rendered, const QString &originator)
+        {
+            Q_ASSERT_X(this->m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
+            return this->m_remoteAircraftProvider->updateAircraftRendered(callsign, rendered, originator);
+        }
+
+        void CRemoteAircraftAware::updateMarkAllAsNotRendered(const QString &originator)
+        {
+            Q_ASSERT_X(this->m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
+            return this->m_remoteAircraftProvider->updateMarkAllAsNotRendered(originator);
+        }
+
         bool CRemoteAircraftAware::isRemoteAircraftSupportingParts(const CCallsign &callsign) const
         {
             Q_ASSERT_X(this->m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
             return this->m_remoteAircraftProvider->isRemoteAircraftSupportingParts(callsign);
         }
 
-        bool CRemoteAircraftAware::providerUpdateAircraftEnabled(const Aviation::CCallsign &callsign, bool enabledForRedering, const QString &originator)
+        bool CRemoteAircraftAware::updateAircraftEnabled(const Aviation::CCallsign &callsign, bool enabledForRedering, const QString &originator)
         {
             Q_ASSERT_X(this->m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
             return this->m_remoteAircraftProvider->updateAircraftEnabled(callsign, enabledForRedering, originator);

src/blackmisc/simulation/remoteaircraftprovider.h

@@ -13,29 +13,47 @@
 #define BLACKMISC_SIMULATION_REMOTEAIRCRAFTPROVIDER_H
 
 #include "blackmisc/blackmiscexport.h"
+#include "blackmisc/simulation/airspaceaircraftsnapshot.h"
 #include "blackmisc/simulation/simulatedaircraftlist.h"
 #include "blackmisc/aviation/aircraftsituationlist.h"
 #include "blackmisc/aviation/aircraftpartslist.h"
+
 #include <functional>
 
 namespace BlackMisc
 {
     namespace Simulation
     {
-        //! Direct in memory access to remote aircraft
+        //! Direct thread safe in memory access to remote aircraft
         //! \note Can not be derived from QObject (as for the signals), as this would create multiple
         //!       inheritance. Hence Q_DECLARE_INTERFACE is used.
-        class BLACKMISC_EXPORT IRemoteAircraftProviderReadOnly
+        class BLACKMISC_EXPORT IRemoteAircraftProvider
         {
         public:
+            static const int MaxSituationsPerCallsign = 6; //!< How many situations per callsign
+            static const int MaxPartsPerCallsign = 3;      //!< How many parts per callsign
+
             //! Situations per callsign
             typedef QHash<BlackMisc::Aviation::CCallsign, BlackMisc::Aviation::CAircraftSituationList> CSituationsPerCallsign;
 
             //! Parts per callsign
             typedef QHash<BlackMisc::Aviation::CCallsign, BlackMisc::Aviation::CAircraftPartsList> CPartsPerCallsign;
 
-            //! All rendered aircraft
+            //! All remote aircraft
-            virtual const CSimulatedAircraftList &remoteAircraft() const = 0;
+            //! \threadsafe
+            virtual BlackMisc::Simulation::CSimulatedAircraftList getAircraftInRange() const = 0;
+
+            //! Count remote aircraft
+            //! \threadsafe
+            virtual int getAircraftInRangeCount() const = 0;
+
+            //! Current snapshot
+            //! \threadsafe
+            virtual BlackMisc::Simulation::CAirspaceAircraftSnapshot getLatestAirspaceAircraftSnapshot() const = 0;
+
+            //! Aircraft for callsign
+            //! \threadsafe
+            virtual BlackMisc::Simulation::CSimulatedAircraft getAircraftInRangeForCallsign(const BlackMisc::Aviation::CCallsign &callsign) const = 0;
 
             //! Rendered aircraft situations (per callsign, time history)
             //! \threadsafe
@@ -47,7 +65,7 @@ namespace BlackMisc
 
             //! All parts (per callsign, time history)
             //! \threadsafe
-            virtual BlackMisc::Aviation::CAircraftPartsList remoteAircraftParts(const BlackMisc::Aviation::CCallsign &callsign, qint64 cutoffTimeBefore = -1) const = 0;
+            virtual BlackMisc::Aviation::CAircraftPartsList remoteAircraftParts(const BlackMisc::Aviation::CCallsign &callsign, qint64 cutoffTimeBefore) const = 0;
 
             //! Is remote aircraft supporting parts?
             //! \threadsafe
@@ -57,112 +75,81 @@ namespace BlackMisc
             //! \threadsafe
             virtual BlackMisc::Aviation::CCallsignSet remoteAircraftSupportingParts() const = 0;
 
-            //! Destructor
-            virtual ~IRemoteAircraftProviderReadOnly() {}
-
-            //! Connect signals to slot receiver. As the interface is no QObject, slots can not be connected directly.
-            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
-            ) = 0;
-
-            static const int MaxSituationsPerCallsign = 6; //!< How many situations per callsign
-            static const int MaxPartsPerCallsign = 3;      //!< How many parts per callsign
-
-            // those signals have to be implemented by classes using the interface.
-        signals:
-            //! New parts got added
-            void addedRemoteAircraftParts(const BlackMisc::Aviation::CAircraftParts &parts);
-
-            //! Aircraft was removed
-            void removedRemoteAircraft(const BlackMisc::Aviation::CCallsign &callsign);
-
-        };
-
-        //! Direct in memory access to own aircraft
-        class BLACKMISC_EXPORT IRemoteAircraftProvider : public IRemoteAircraftProviderReadOnly
-        {
-        public:
-
-            //! The read only /sa IRemoteAircraftProviderReadOnly::remoteAircraft
-            using IRemoteAircraftProviderReadOnly::remoteAircraft;
-
-            //! All rendered aircraft
-            //! \note in memory reference, not thread safe
-            virtual CSimulatedAircraftList &remoteAircraft() = 0;
-
             //! Enable/disable rendering
+            //! \threadsafe
             virtual bool updateAircraftEnabled(const BlackMisc::Aviation::CCallsign &callsign, bool enabledForRendering, const QString &originator) = 0;
 
+            //! Rendered?
+            //! \threadsafe
+            virtual bool updateAircraftRendered(const BlackMisc::Aviation::CCallsign &callsign, bool rendered, const QString &originator) = 0;
+
+            //! Mark all as not rendered
+            //! \threadsafe
+            virtual void updateMarkAllAsNotRendered(const QString &originator) = 0;
+
             //! Change model string
+            //! \threadsafe
             virtual bool updateAircraftModel(const BlackMisc::Aviation::CCallsign &callsign, const BlackMisc::Simulation::CAircraftModel &model, const QString &originator) = 0;
 
             //! Change fast position updates
+            //! \threadsafe
             virtual bool updateFastPositionEnabled(const BlackMisc::Aviation::CCallsign &callsign, bool enableFastPositonUpdates, const QString &originator) = 0;
-        };
-
-        //! Class which can be directly used to access an \sa IRemoteAircraftProviderReadOnly object
-        class BLACKMISC_EXPORT CRemoteAircraftAwareReadOnly
-        {
-        public:
-            //! \copydoc IRemoteAircraftProviderReadOnly::renderedAircraft
-            virtual const CSimulatedAircraftList &remoteAircraft() const;
-
-            //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraftSituations
-            virtual BlackMisc::Aviation::CAircraftSituationList remoteAircraftSituations(const BlackMisc::Aviation::CCallsign &callsign) const;
-
-            //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraftSituationsCount
-            virtual int remoteAircraftSituationsCount(const BlackMisc::Aviation::CCallsign &callsign) const;
-
-            //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraftParts
-            virtual BlackMisc::Aviation::CAircraftPartsList remoteAircraftParts(const BlackMisc::Aviation::CCallsign &callsign, qint64 cutoffTimeBefore = -1) const;
-
-            //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraftSupportingParts
-            virtual BlackMisc::Aviation::CCallsignSet remoteAircraftSupportingParts() const;
-
-            //! \copydoc IRemoteAircraftProviderReadOnly::isRemoteAircraftSupportingParts
-            virtual bool isRemoteAircraftSupportingParts(const BlackMisc::Aviation::CCallsign &callsign) const;
 
             //! Destructor
-            virtual ~CRemoteAircraftAwareReadOnly() {}
+            virtual ~IRemoteAircraftProvider() {}
+
+            //! Connect signals to slot receiver. As the interface is no QObject, slots can not be connected directly.
+            virtual bool connectRemoteAircraftProviderSignals(
+                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 &)> aircraftSnapshot
+            ) = 0;
 
-        protected:
-            //! Constructor
-            CRemoteAircraftAwareReadOnly(const IRemoteAircraftProviderReadOnly *remoteAircraftProvider) : m_remoteAircraftProvider(remoteAircraftProvider) {}
-            const IRemoteAircraftProviderReadOnly *m_remoteAircraftProvider = nullptr; //!< access to object
         };
 
         //! Class which can be directly used to access an \sa IRemoteAircraftProvider object
-        class BLACKMISC_EXPORT CRemoteAircraftAware
+        class CRemoteAircraftAware
         {
         public:
-            //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraft
+            //! \copydoc IRemoteAircraftProvider::getAircraftInRange
-            virtual const CSimulatedAircraftList &remoteAircraft() const;
+            virtual BlackMisc::Simulation::CSimulatedAircraftList getAircraftInRange() const;
 
-            //! \copydoc IRemoteAircraftProvider::remoteAircraft
+            //! \copydoc IRemoteAircraftProvider::getAircraftInRangeCount
-            virtual CSimulatedAircraftList &remoteAircraft();
+            int getAircraftInRangeCount() const;
 
-            //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraftSituations
+            //! \copydoc IRemoteAircraftProvider::getAircraftInRangeForCallsign
+            virtual BlackMisc::Simulation::CSimulatedAircraft getAircraftInRangeForCallsign(const Aviation::CCallsign &callsign) const;
+
+            //! \copydoc IRemoteAircraftProvider::getLatestAirspaceAircraftSnapshot
+            virtual BlackMisc::Simulation::CAirspaceAircraftSnapshot getLatestAirspaceAircraftSnapshot() const;
+
+            //! \copydoc IRemoteAircraftProvider::remoteAircraftSituations
             virtual BlackMisc::Aviation::CAircraftSituationList remoteAircraftSituations(const BlackMisc::Aviation::CCallsign &callsign) const;
 
-            //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraftParts
+            //! \copydoc IRemoteAircraftProvider::remoteAircraftParts
-            virtual BlackMisc::Aviation::CAircraftPartsList remoteAircraftParts(const BlackMisc::Aviation::CCallsign &callsign) const;
+            virtual BlackMisc::Aviation::CAircraftPartsList remoteAircraftParts(const BlackMisc::Aviation::CCallsign &callsign, qint64 cutoffTimeBefore) const;
 
-            //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraftSupportingParts
+            //! \copydoc IRemoteAircraftProvider::remoteAircraftSupportingParts
             virtual BlackMisc::Aviation::CCallsignSet remoteAircraftSupportingParts() const;
 
-            //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraftSituationsCount
+            //! \copydoc IRemoteAircraftProvider::remoteAircraftSituationsCount
             virtual int remoteAircraftSituationsCount(const BlackMisc::Aviation::CCallsign &callsign) const;
 
+            //! \copydoc IRemoteAircraftProvider::isRemoteAircraftSupportingParts
+            virtual bool isRemoteAircraftSupportingParts(const BlackMisc::Aviation::CCallsign &callsign) const;
+
             //! \copydoc IRemoteAircraftProvider::updateAircraftEnabled
-            virtual bool providerUpdateAircraftEnabled(const BlackMisc::Aviation::CCallsign &callsign, bool enabledForRedering, const QString &originator);
+            virtual bool updateAircraftEnabled(const BlackMisc::Aviation::CCallsign &callsign, bool enabledForRedering, const QString &originator);
 
             //! \copydoc IRemoteAircraftProvider::updateAircraftModel
-            virtual bool providerUpdateAircraftModel(const BlackMisc::Aviation::CCallsign &callsign, const BlackMisc::Simulation::CAircraftModel &model, const QString &originator);
+            virtual bool updateAircraftModel(const BlackMisc::Aviation::CCallsign &callsign, const BlackMisc::Simulation::CAircraftModel &model, const QString &originator);
 
-            //! \copydoc IRemoteAircraftProviderReadOnly::isRemoteAircraftSupportingParts
+            //! \copydoc IRemoteAircraftProvider::updateAircraftRendered
-            virtual bool isRemoteAircraftSupportingParts(const BlackMisc::Aviation::CCallsign &callsign) const;
+            virtual bool updateAircraftRendered(const BlackMisc::Aviation::CCallsign &callsign, bool rendered, const QString &originator);
+
+            //! \copydoc IRemoteAircraftProvider::updateMarkAllAsNotRendered
+            virtual void updateMarkAllAsNotRendered(const QString &originator);
 
             //! Destructor
             virtual ~CRemoteAircraftAware() {}
@@ -176,7 +163,6 @@ namespace BlackMisc
     } // namespace
 } // namespace
 
-Q_DECLARE_INTERFACE(BlackMisc::Simulation::IRemoteAircraftProviderReadOnly, "IRemoteAircraftProviderReadOnly")
 Q_DECLARE_INTERFACE(BlackMisc::Simulation::IRemoteAircraftProvider, "IRemoteAircraftProvider")
 
 #endif // guard

src/blackmisc/simulation/remoteaircraftproviderdummy.cpp

@@ -19,14 +19,19 @@ namespace BlackMisc
         CRemoteAircraftProviderDummy::CRemoteAircraftProviderDummy(QObject *parent) : QObject(parent)
         { }
 
-        const CSimulatedAircraftList &CRemoteAircraftProviderDummy::remoteAircraft() const
+        CSimulatedAircraftList CRemoteAircraftProviderDummy::getAircraftInRange() const
         {
             return m_aircraft;
         }
 
-        CSimulatedAircraftList &CRemoteAircraftProviderDummy::remoteAircraft()
+        int CRemoteAircraftProviderDummy::getAircraftInRangeCount() const
         {
-            return m_aircraft;
+            return m_aircraft.size();
+        }
+
+        CSimulatedAircraft CRemoteAircraftProviderDummy::getAircraftForCallsign(const CCallsign &callsign) const
+        {
+            return m_aircraft.findFirstByCallsign(callsign);
         }
 
         CAircraftPartsList CRemoteAircraftProviderDummy::remoteAircraftParts(const BlackMisc::Aviation::CCallsign &callsign, qint64 cutoffTimeBefore) const
@@ -87,6 +92,20 @@ namespace BlackMisc
             return n > 0;
         }
 
+        bool CRemoteAircraftProviderDummy::updateAircraftRendered(const CCallsign &callsign, bool rendered, const QString &originator)
+        {
+            Q_UNUSED(originator);
+            CPropertyIndexVariantMap vm(CSimulatedAircraft::IndexRendered, CVariant::fromValue(rendered));
+            int n = this->m_aircraft.applyIfCallsign(callsign, vm);
+            return n > 0;
+        }
+
+        void CRemoteAircraftProviderDummy::updateMarkAllAsNotRendered(const QString &originator)
+        {
+            Q_UNUSED(originator);
+            this->m_aircraft.markAllAsNotRendered();
+        }
+
         void CRemoteAircraftProviderDummy::insertNewSituation(const CAircraftSituation &situation)
         {
             this->m_situations.push_front(situation);

src/blackmisc/simulation/remoteaircraftproviderdummy.h

@@ -32,28 +32,31 @@ namespace BlackMisc
             //! Constructor
             CRemoteAircraftProviderDummy(QObject *parent = nullptr);
 
-            //! IRemoteAircraftProviderReadOnly::remoteAircraft
+            //! IRemoteAircraftProvider::getAircraftInRange
-            virtual const CSimulatedAircraftList &remoteAircraft() const override;
+            virtual CSimulatedAircraftList getAircraftInRange() const override;
 
-            //! IRemoteAircraftProvider::remoteAircraft
+            //! IRemoteAircraftProvider::getAircraftInRangeCount
-            virtual CSimulatedAircraftList &remoteAircraft() override;
+            virtual int getAircraftInRangeCount() const override;
 
-            //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraftParts
+            //! IRemoteAircraftProvider::getAircraftForCallsign
+            virtual BlackMisc::Simulation::CSimulatedAircraft getAircraftForCallsign(const BlackMisc::Aviation::CCallsign &callsign) const override;
+
+            //! \copydoc IRemoteAircraftProvider::remoteAircraftParts
             virtual BlackMisc::Aviation::CAircraftPartsList remoteAircraftParts(const Aviation::CCallsign &callsign, qint64 cutoffTimeBefore = -1) const override;
 
-            //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraftSituations
+            //! \copydoc IRemoteAircraftProvider::remoteAircraftSituations
             virtual BlackMisc::Aviation::CAircraftSituationList remoteAircraftSituations(const Aviation::CCallsign &callsign) const override;
 
-            //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraftSituationsCount
+            //! \copydoc IRemoteAircraftProvider::remoteAircraftSituationsCount
             virtual int remoteAircraftSituationsCount(const Aviation::CCallsign &callsign) const override;
 
-            //! \copydoc IRemoteAircraftProviderReadOnly::remoteAircraftSupportingParts
+            //! \copydoc IRemoteAircraftProvider::remoteAircraftSupportingParts
             virtual BlackMisc::Aviation::CCallsignSet remoteAircraftSupportingParts() const override;
 
-            //! \copydoc IRemoteAircraftProviderReadOnly::isRemoteAircraftSupportingParts
+            //! \copydoc IRemoteAircraftProvider::isRemoteAircraftSupportingParts
             virtual bool isRemoteAircraftSupportingParts(const Aviation::CCallsign &callsign) const override;
 
-            //! \copydoc IRemoteAircraftProviderReadOnly::connectRemoteAircraftProviderSignals
+            //! \copydoc IRemoteAircraftProvider::connectRemoteAircraftProviderSignals
             virtual bool connectRemoteAircraftProviderSignals(
                 std::function<void(const BlackMisc::Aviation::CAircraftSituation &)> situationSlot,
                 std::function<void(const BlackMisc::Aviation::CAircraftParts &)> partsSlot,
@@ -69,6 +72,12 @@ namespace BlackMisc
             //! \copydoc IRemoteAircraftProvider::updateFastPositionEnabled
             virtual bool updateFastPositionEnabled(const Aviation::CCallsign &callsign, bool enableFastPositionUpdates, const QString &originator) override;
 
+            //! \copydoc IRemoteAircraftProvider::updateAircraftRendered
+            virtual bool updateAircraftRendered(const Aviation::CCallsign &callsign, bool rendered, const QString &originator) override;
+
+            //! \copydoc IRemoteAircraftProvider::updateMarkAllAsNotRendered
+            virtual void updateMarkAllAsNotRendered(const QString &originator) override;
+
             //! For testing, add new situation and fire signals
             void insertNewSituation(const BlackMisc::Aviation::CAircraftSituation &situation);
 
@@ -79,13 +88,13 @@ namespace BlackMisc
             void clear();
 
         signals:
-            //! \copydoc IRemoteAircraftProviderReadOnly::addedRemoteAircraftSituation
+            //! Added situation
             void addedRemoteAircraftSituation(const BlackMisc::Aviation::CAircraftSituation &situation);
 
-            //! \copydoc IRemoteAircraftProviderReadOnly::addedRemoteAircraftParts
+            //! Added parts
             void addedRemoteAircraftParts(const BlackMisc::Aviation::CAircraftParts &parts);
 
-            //! \copydoc IRemoteAircraftProviderReadOnly::removedRemoteAircraft
+            //! Added aircraft
             void removedRemoteAircraft(const BlackMisc::Aviation::CCallsign &callsign);
 
         private:

src/blackmisc/simulation/simulatedaircraft.cpp

@@ -74,6 +74,7 @@ namespace BlackMisc
             {
             case IndexModel:
                 this->m_model.setPropertyByIndex(variant, index.copyFrontRemoved());
+                this->setModel(this->m_model); // sync some values
                 break;
             case IndexClient:
                 this->m_client.setPropertyByIndex(variant, index.copyFrontRemoved());

src/plugins/simulator/fs9/simulator_fs9.cpp

@@ -108,7 +108,7 @@ namespace BlackSimPlugin
 
             client->start();
             m_hashFs9Clients.insert(callsign, client);
-            remoteAircraft().applyIfCallsign(callsign, CPropertyIndexVariantMap(CSimulatedAircraft::IndexRendered, CVariant::fromValue(true)));
+            updateAircraftRendered(callsign, true, this->simulatorOriginator());
             CLogMessage(this).info("FS9: Added aircraft %1") << callsign.toQString();
             return true;
         }
@@ -120,7 +120,7 @@ namespace BlackSimPlugin
             auto fs9Client = m_hashFs9Clients.value(callsign);
             fs9Client->quit();
             m_hashFs9Clients.remove(callsign);
-            remoteAircraft().setRendered(callsign, false);
+            updateAircraftRendered(callsign, false, this->simulatorOriginator());
             CLogMessage(this).info("FS9: Removed aircraft %1") << callsign.toQString();
             return true;
         }

src/plugins/simulator/fsx/simulator_fsx.cpp

@@ -163,9 +163,9 @@ namespace BlackSimPlugin
 
             // matched models
             CAircraftModel aircraftModel = modelMatching(newRemoteAircraftCopy);
-            Q_ASSERT(newRemoteAircraft.getCallsign() == aircraftModel.getCallsign());
+            Q_ASSERT_X(newRemoteAircraft.getCallsign() == aircraftModel.getCallsign(), Q_FUNC_INFO, "mismatching callsigns");
-            this->providerUpdateAircraftModel(newRemoteAircraft.getCallsign(), aircraftModel, simulatorOriginator());
+            this->updateAircraftModel(newRemoteAircraft.getCallsign(), aircraftModel, simulatorOriginator());
-            CSimulatedAircraft aircraftAfterModelApplied = remoteAircraft().findFirstByCallsign(newRemoteAircraft.getCallsign());
+            CSimulatedAircraft aircraftAfterModelApplied(getAircraftForCallsign(newRemoteAircraft.getCallsign()));
             aircraftAfterModelApplied.setRendered(true);
             emit modelMatchingCompleted(aircraftAfterModelApplied);
 
@@ -523,9 +523,10 @@ namespace BlackSimPlugin
 
         bool CSimulatorFsx::removeRemoteAircraft(const CSimConnectObject &simObject)
         {
-            m_simConnectObjects.remove(simObject.getCallsign());
+            CCallsign callsign(simObject.getCallsign());
+            m_simConnectObjects.remove(callsign);
             SimConnect_AIRemoveObject(m_hSimConnect, static_cast<SIMCONNECT_OBJECT_ID>(simObject.getObjectId()), static_cast<SIMCONNECT_DATA_REQUEST_ID>(simObject.getRequestId()));
-            remoteAircraft().setRendered(simObject.getCallsign(), false);
+            updateAircraftRendered(callsign, false, simulatorOriginator());
             CLogMessage(this).info("FSX: Removed aircraft %1") << simObject.getCallsign().toQString();
             return true;
         }
@@ -615,7 +616,7 @@ namespace BlackSimPlugin
 
             // nothing to do, reset request id and exit
             if (this->isPaused()) { return; } // no interpolation while paused
-            int remoteAircraftNo = this->remoteAircraft().size();
+            int remoteAircraftNo = this->getAircraftInRangeCount();
             if (remoteAircraftNo < 1) { m_interpolationRequest = 0;  return; }
 
             // interpolate and send to SIM

src/plugins/simulator/xplane/simulator_xplane.cpp

@@ -329,7 +329,7 @@ namespace BlackSimPlugin
         {
             //! \todo XP implement isRenderedAircraft correctly
             // work around, but not really telling me if callsign is really(!) visible in SIM
-            return remoteAircraft().findFirstByCallsign(callsign).isRendered();
+            return getAircraftForCallsign(callsign).isRendered();
         }
 
         bool CSimulatorXPlane::updateOwnSimulatorCockpit(const BlackMisc::Aviation::CAircraft &aircraft, const QString &originator)
@@ -369,7 +369,7 @@ namespace BlackSimPlugin
             // Is there any model matching required ????
             CAircraftIcao icao = newRemoteAircraft.getIcaoInfo();
             m_traffic->addPlane(newRemoteAircraft.getCallsign().asString(), icao.getAircraftDesignator(), icao.getAirlineDesignator(), icao.getLivery());
-            remoteAircraft().applyIfCallsign(newRemoteAircraft.getCallsign(), CPropertyIndexVariantMap(CSimulatedAircraft::IndexRendered, CVariant::fromValue(true)));
+            updateAircraftRendered(newRemoteAircraft.getCallsign(), true, simulatorOriginator());
             CLogMessage(this).info("XP: Added aircraft %1") << newRemoteAircraft.getCallsign().toQString();
             return true;
         }
@@ -404,7 +404,7 @@ namespace BlackSimPlugin
         {
             Q_ASSERT(isConnected());
             m_traffic->removePlane(callsign.asString());
-            remoteAircraft().setRendered(callsign, false);
+            updateAircraftRendered(callsign, false, simulatorOriginator());
             CLogMessage(this).info("XP: Removed aircraft %1") << callsign.toQString();
             return true;
         }
@@ -412,7 +412,7 @@ namespace BlackSimPlugin
         void CSimulatorXPlane::removeAllRemoteAircraft()
         {
             m_traffic->removeAllPlanes();
-            remoteAircraft().markAllAsNotRendered();
+            updateMarkAllAsNotRendered(simulatorOriginator());
             CLogMessage(this).info("XP: Removed all aircraft");
         }
 

tests/blackcore/testinterpolator.cpp

@@ -30,7 +30,7 @@ namespace BlackCoreTest
         const qint64 ts =  1425000000000; // QDateTime::currentMSecsSinceEpoch();
         const qint64 deltaT = 5000; // ms
         CCallsign cs("SWIFT");
-        for (int i = 0; i < IRemoteAircraftProviderReadOnly::MaxSituationsPerCallsign; i++)
+        for (int i = 0; i < IRemoteAircraftProvider::MaxSituationsPerCallsign; i++)
         {
             CAircraftSituation s(getTestSituation(cs, i, ts, deltaT));
 
@@ -40,7 +40,7 @@ namespace BlackCoreTest
             provider->insertNewSituation(s);
         }
 
-        for (int i = 0; i < IRemoteAircraftProviderReadOnly::MaxPartsPerCallsign; i++)
+        for (int i = 0; i < IRemoteAircraftProvider::MaxPartsPerCallsign; i++)
         {
             CAircraftParts p(getTestParts(cs, i, ts, deltaT));
             provider->insertNewAircraftParts(p);
@@ -50,8 +50,8 @@ namespace BlackCoreTest
         QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
 
         // check if all situations / parts have been received
-        QVERIFY2(provider->remoteAircraftSituations(cs).size() == IRemoteAircraftProviderReadOnly::MaxSituationsPerCallsign, "Missing situations");
+        QVERIFY2(provider->remoteAircraftSituations(cs).size() == IRemoteAircraftProvider::MaxSituationsPerCallsign, "Missing situations");
-        QVERIFY2(provider->remoteAircraftParts(cs).size() == IRemoteAircraftProviderReadOnly::MaxPartsPerCallsign, "Missing parts");
+        QVERIFY2(provider->remoteAircraftParts(cs).size() == IRemoteAircraftProvider::MaxPartsPerCallsign, "Missing parts");
 
         // interpolation functional check
         IInterpolator::InterpolationStatus status;