Ref T259, Ref T243 adjusted providers to use common base classes

src/blackmisc/simulation/ownaircraftprovider.cpp

@@ -26,92 +26,92 @@ namespace BlackMisc
 
         CSimulatedAircraft COwnAircraftAware::getOwnAircraft() const
         {
-            Q_ASSERT_X(m_ownAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_ownAircraftProvider->getOwnAircraft();
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->getOwnAircraft();
         }
 
         CCoordinateGeodetic COwnAircraftAware::getOwnAircraftPosition() const
         {
-            Q_ASSERT_X(m_ownAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_ownAircraftProvider->getOwnAircraftPosition();
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->getOwnAircraftPosition();
         }
 
         CAircraftSituation COwnAircraftAware::getOwnAircraftSituation() const
         {
-            Q_ASSERT_X(m_ownAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_ownAircraftProvider->getOwnAircraftSituation();
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->getOwnAircraftSituation();
         }
 
         CAircraftParts COwnAircraftAware::getOwnAircraftParts() const
         {
-            Q_ASSERT_X(m_ownAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_ownAircraftProvider->getOwnAircraftParts();
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->getOwnAircraftParts();
         }
 
         CAircraftModel COwnAircraftAware::getOwnAircraftModel() const
         {
-            Q_ASSERT_X(m_ownAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_ownAircraftProvider->getOwnAircraftModel();
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->getOwnAircraftModel();
         }
 
         CLength COwnAircraftAware::getDistanceToOwnAircraft(const Geo::ICoordinateGeodetic &position) const
         {
-            Q_ASSERT_X(m_ownAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_ownAircraftProvider->getDistanceToOwnAircraft(position);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->getDistanceToOwnAircraft(position);
         }
 
         bool COwnAircraftAware::updateCockpit(const CSimulatedAircraft &aircraft, const CIdentifier &originator)
         {
-            Q_ASSERT_X(m_ownAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_ownAircraftProvider->updateCockpit(aircraft, originator);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->updateCockpit(aircraft, originator);
         }
 
         bool COwnAircraftAware::updateCockpit(const CComSystem &com1, const CComSystem &com2, const CTransponder &transponder, const CIdentifier &originator)
         {
-            Q_ASSERT_X(m_ownAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_ownAircraftProvider->updateCockpit(com1, com2, transponder, originator);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->updateCockpit(com1, com2, transponder, originator);
         }
 
         bool COwnAircraftAware::updateActiveComFrequency(const CFrequency &frequency, CComSystem::ComUnit comUnit, const CIdentifier &originator)
         {
-            Q_ASSERT_X(m_ownAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_ownAircraftProvider->updateActiveComFrequency(frequency, comUnit, originator);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->updateActiveComFrequency(frequency, comUnit, originator);
         }
 
         bool COwnAircraftAware::updateSelcal(const CSelcal &selcal, const CIdentifier &originator)
         {
-            Q_ASSERT_X(m_ownAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_ownAircraftProvider->updateSelcal(selcal, originator);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->updateSelcal(selcal, originator);
         }
 
         bool COwnAircraftAware::updateOwnModel(const CAircraftModel &model)
         {
-            Q_ASSERT_X(m_ownAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_ownAircraftProvider->updateOwnModel(model);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->updateOwnModel(model);
         }
 
         bool COwnAircraftAware::updateOwnSituation(const CAircraftSituation &situation)
         {
-            Q_ASSERT_X(m_ownAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_ownAircraftProvider->updateOwnSituation(situation);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->updateOwnSituation(situation);
         }
 
         bool COwnAircraftAware::updateOwnParts(const CAircraftParts &parts)
         {
-            Q_ASSERT_X(m_ownAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_ownAircraftProvider->updateOwnParts(parts);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->updateOwnParts(parts);
         }
 
         bool COwnAircraftAware::updateOwnCallsign(const CCallsign &callsign)
         {
-            Q_ASSERT_X(m_ownAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_ownAircraftProvider->updateOwnCallsign(callsign);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->updateOwnCallsign(callsign);
         }
 
         bool COwnAircraftAware::updateOwnIcaoCodes(const CAircraftIcaoCode &aircraftIcaoData, const CAirlineIcaoCode &airlineIcaoCode)
         {
-            Q_ASSERT_X(m_ownAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_ownAircraftProvider->updateOwnIcaoCodes(aircraftIcaoData, airlineIcaoCode);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->updateOwnIcaoCodes(aircraftIcaoData, airlineIcaoCode);
         }
     } // namespace
 } // namespace

src/blackmisc/simulation/ownaircraftprovider.h

@@ -12,17 +12,18 @@
 #ifndef BLACKMISC_SIMULATION_OWNAIRCRAFTPROVIDER_H
 #define BLACKMISC_SIMULATION_OWNAIRCRAFTPROVIDER_H
 
+#include "blackmisc/simulation/aircraftmodel.h"
+#include "blackmisc/simulation/simulatedaircraft.h"
 #include "blackmisc/aviation/aircraftparts.h"
 #include "blackmisc/aviation/airlineicaocode.h"
 #include "blackmisc/aviation/comsystem.h"
 #include "blackmisc/aviation/selcal.h"
-#include "blackmisc/blackmiscexport.h"
 #include "blackmisc/geo/coordinategeodetic.h"
-#include "blackmisc/identifier.h"
 #include "blackmisc/pq/frequency.h"
 #include "blackmisc/pq/length.h"
-#include "blackmisc/simulation/aircraftmodel.h"
-#include "blackmisc/simulation/simulatedaircraft.h"
+#include "blackmisc/provider.h"
+#include "blackmisc/blackmiscexport.h"
+#include "blackmisc/identifier.h"
 
 #include <QObject>
 #include <QtGlobal>
@@ -40,7 +41,7 @@ namespace BlackMisc
     namespace Simulation
     {
         //! Direct threadsafe in memory access to own aircraft
-        class BLACKMISC_EXPORT IOwnAircraftProvider
+        class BLACKMISC_EXPORT IOwnAircraftProvider : public IProvider
         {
         public:
             //! Own aircraft
@@ -108,9 +109,12 @@ namespace BlackMisc
         };
 
         //! Delegating class which can be directly used to access an \sa IOwnAircraftProvider instance
-        class BLACKMISC_EXPORT COwnAircraftAware
+        class BLACKMISC_EXPORT COwnAircraftAware : public IProviderAware<IOwnAircraftProvider>
         {
         public:
+            //! Set the provider
+            void setOwnAircraftProvider(IOwnAircraftProvider *provider) { this->setProvider(provider); }
+
             //! \copydoc IOwnAircraftProvider::getOwnAircraft
             CSimulatedAircraft getOwnAircraft() const;
 
@@ -158,8 +162,7 @@ namespace BlackMisc
 
         protected:
             //! Constructor
-            COwnAircraftAware(IOwnAircraftProvider *ownAircraftProvider) : m_ownAircraftProvider(ownAircraftProvider) { Q_ASSERT(ownAircraftProvider); }
-            IOwnAircraftProvider *m_ownAircraftProvider = nullptr; //!< access to object
+            COwnAircraftAware(IOwnAircraftProvider *ownAircraftProvider) : IProviderAware(ownAircraftProvider) { Q_ASSERT(ownAircraftProvider); }
         };
     } // namespace
 } // namespace

src/blackmisc/simulation/remoteaircraftprovider.cpp

@@ -18,116 +18,116 @@ namespace BlackMisc
     {
         CSimulatedAircraftList CRemoteAircraftAware::getAircraftInRange() const
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_remoteAircraftProvider->getAircraftInRange();
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->getAircraftInRange();
         }
 
         bool CRemoteAircraftAware::isAircraftInRange(const CCallsign &callsign) const
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_remoteAircraftProvider->isAircraftInRange(callsign);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->isAircraftInRange(callsign);
         }
 
         int CRemoteAircraftAware::getAircraftInRangeCount() const
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_remoteAircraftProvider->getAircraftInRangeCount();
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->getAircraftInRangeCount();
         }
 
         CCallsignSet CRemoteAircraftAware::getAircraftInRangeCallsigns() const
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_remoteAircraftProvider->getAircraftInRangeCallsigns();
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->getAircraftInRangeCallsigns();
         }
 
         CSimulatedAircraft CRemoteAircraftAware::getAircraftInRangeForCallsign(const CCallsign &callsign) const
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_remoteAircraftProvider->getAircraftInRangeForCallsign(callsign);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->getAircraftInRangeForCallsign(callsign);
         }
 
         CAircraftModel CRemoteAircraftAware::getAircraftInRangeModelForCallsign(const CCallsign &callsign) const
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_remoteAircraftProvider->getAircraftInRangeModelForCallsign(callsign);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->getAircraftInRangeModelForCallsign(callsign);
         }
 
         CAirspaceAircraftSnapshot CRemoteAircraftAware::getLatestAirspaceAircraftSnapshot() const
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_remoteAircraftProvider->getLatestAirspaceAircraftSnapshot();
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->getLatestAirspaceAircraftSnapshot();
         }
 
         CAircraftSituationList CRemoteAircraftAware::remoteAircraftSituations(const BlackMisc::Aviation::CCallsign &callsign) const
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_remoteAircraftProvider->remoteAircraftSituations(callsign);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->remoteAircraftSituations(callsign);
         }
 
         CAircraftPartsList CRemoteAircraftAware::remoteAircraftParts(const CCallsign &callsign, qint64 cutoffTimeBefore) const
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_remoteAircraftProvider->remoteAircraftParts(callsign, cutoffTimeBefore);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->remoteAircraftParts(callsign, cutoffTimeBefore);
         }
 
         CCallsignSet CRemoteAircraftAware::remoteAircraftSupportingParts() const
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_remoteAircraftProvider->remoteAircraftSupportingParts();
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->remoteAircraftSupportingParts();
         }
 
         int CRemoteAircraftAware::remoteAircraftSituationsCount(const CCallsign &callsign) const
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_remoteAircraftProvider->remoteAircraftSituationsCount(callsign);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->remoteAircraftSituationsCount(callsign);
         }
 
         bool CRemoteAircraftAware::updateAircraftModel(const Aviation::CCallsign &callsign, const CAircraftModel &model, const CIdentifier &originator)
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_remoteAircraftProvider->updateAircraftModel(callsign, model, originator);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->updateAircraftModel(callsign, model, originator);
         }
 
         bool CRemoteAircraftAware::updateAircraftNetworkModel(const CCallsign &callsign, const CAircraftModel &model, const CIdentifier &originator)
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_remoteAircraftProvider->updateAircraftNetworkModel(callsign, model, originator);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->updateAircraftNetworkModel(callsign, model, originator);
         }
 
         bool CRemoteAircraftAware::updateAircraftRendered(const CCallsign &callsign, bool rendered)
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_remoteAircraftProvider->updateAircraftRendered(callsign, rendered);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->updateAircraftRendered(callsign, rendered);
         }
 
         bool CRemoteAircraftAware::updateAircraftGroundElevation(const CCallsign &callsign, const CElevationPlane &elevation)
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_remoteAircraftProvider->updateAircraftGroundElevation(callsign, elevation);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->updateAircraftGroundElevation(callsign, elevation);
         }
 
         void CRemoteAircraftAware::updateMarkAllAsNotRendered()
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            m_remoteAircraftProvider->updateMarkAllAsNotRendered();
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            this->provider()->updateMarkAllAsNotRendered();
         }
 
         bool CRemoteAircraftAware::isRemoteAircraftSupportingParts(const CCallsign &callsign) const
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_remoteAircraftProvider->isRemoteAircraftSupportingParts(callsign);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->isRemoteAircraftSupportingParts(callsign);
         }
 
         int CRemoteAircraftAware::getRemoteAircraftSupportingPartsCount() const
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_remoteAircraftProvider->getRemoteAircraftSupportingPartsCount();
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->getRemoteAircraftSupportingPartsCount();
         }
 
         bool CRemoteAircraftAware::updateAircraftEnabled(const CCallsign &callsign, bool enabledForRedering)
         {
-            Q_ASSERT_X(m_remoteAircraftProvider, Q_FUNC_INFO, "No object available");
-            return m_remoteAircraftProvider->updateAircraftEnabled(callsign, enabledForRedering);
+            Q_ASSERT_X(this->provider(), Q_FUNC_INFO, "No object available");
+            return this->provider()->updateAircraftEnabled(callsign, enabledForRedering);
         }
 
         CAircraftParts IRemoteAircraftProvider::getLatestAircraftParts(const CCallsign &callsign) const

src/blackmisc/simulation/remoteaircraftprovider.h

@@ -19,6 +19,7 @@
 #include "blackmisc/aviation/aircraftpartslist.h"
 #include "blackmisc/aviation/aircraftsituationlist.h"
 #include "blackmisc/aviation/callsignset.h"
+#include "blackmisc/provider.h"
 #include "blackmisc/blackmiscexport.h"
 #include "blackmisc/identifier.h"
 
@@ -44,7 +45,7 @@ namespace BlackMisc
         //! \note Can not be derived from QObject (as for the signals), as this would create multiple
         //!       inheritance. Hence Q_DECLARE_INTERFACE is used.
         //! \ingroup remoteaircraftprovider
-        class BLACKMISC_EXPORT IRemoteAircraftProvider
+        class BLACKMISC_EXPORT IRemoteAircraftProvider : public IProvider
         {
         public:
             static constexpr int MaxSituationsPerCallsign = 6;    //!< How many situations we keep per callsign
@@ -185,7 +186,7 @@ namespace BlackMisc
         };
 
         //! Class which can be directly used to access an \sa IRemoteAircraftProvider object
-        class BLACKMISC_EXPORT CRemoteAircraftAware
+        class BLACKMISC_EXPORT CRemoteAircraftAware : public IProviderAware<IRemoteAircraftProvider>
         {
         public:
             //! \copydoc IRemoteAircraftProvider::getAircraftInRange
@@ -246,15 +247,14 @@ namespace BlackMisc
             void updateMarkAllAsNotRendered();
 
             //! Set remote aircraft provider
-            void setRemoteAircraftProvider(IRemoteAircraftProvider *remoteAircraftProvider) { m_remoteAircraftProvider = remoteAircraftProvider; }
+            void setRemoteAircraftProvider(IRemoteAircraftProvider *remoteAircraftProvider) { this->setProvider(remoteAircraftProvider); }
 
         protected:
             //! Default constructor
             CRemoteAircraftAware() {}
 
             //! Constructor
-            CRemoteAircraftAware(IRemoteAircraftProvider *remoteAircraftProvider) : m_remoteAircraftProvider(remoteAircraftProvider) { Q_ASSERT(remoteAircraftProvider); }
-            IRemoteAircraftProvider *m_remoteAircraftProvider = nullptr; //!< access to object
+            CRemoteAircraftAware(IRemoteAircraftProvider *remoteAircraftProvider) : IProviderAware(remoteAircraftProvider) { Q_ASSERT(remoteAircraftProvider); }
         };
     } // namespace
 } // namespace

src/blackmisc/simulation/simulationenvironmentprovider.cpp

@@ -9,7 +9,9 @@
 
 #include "simulationenvironmentprovider.h"
 
+using namespace BlackMisc::Aviation;
 using namespace BlackMisc::Geo;
+using namespace BlackMisc::PhysicalQuantities;
 
 namespace BlackMisc
 {
@@ -34,6 +36,28 @@ namespace BlackMisc
             return this->rememberGroundElevation(elevationPlane, elevationPlane.getRadius());
         }
 
+        bool ISimulationEnvironmentProvider::insertCG(const CLength &cg, const Aviation::CCallsign &cs)
+        {
+            if (cs.isEmpty()) { return false; }
+            const bool remove = cg.isNull();
+            QWriteLocker l(&m_lockCG);
+            if (remove)
+            {
+                m_cgs.remove(cs);
+            }
+            else
+            {
+                m_cgs[cs] = cg;
+            }
+            return true;
+        }
+
+        int ISimulationEnvironmentProvider::removeCG(const CCallsign &cs)
+        {
+            QWriteLocker l(&m_lockCG);
+            return m_cgs.remove(cs);
+        }
+
         CCoordinateGeodeticList ISimulationEnvironmentProvider::getElevationCoordinates() const
         {
             QReadLocker l(&m_lockElvCoordinates);
@@ -58,16 +82,105 @@ namespace BlackMisc
             return this->getElevationCoordinates().findClosestWithinRange(reference, range);
         }
 
-        void ISimulationEnvironmentProvider::clearSimulationEnvironmentData()
+        CSimulatorPluginInfo ISimulationEnvironmentProvider::getSimulatorPluginInfo() const
+        {
+            QReadLocker l(&m_lockModel);
+            return m_simulatorPluginInfo;
+        }
+
+        CSimulatorInfo ISimulationEnvironmentProvider::getSimulatorInfo() const
+        {
+            return this->getSimulatorPluginInfo().getSimulatorInfo();
+        }
+
+        CAircraftModel ISimulationEnvironmentProvider::getDefaultModel() const
+        {
+            QReadLocker l(&m_lockModel);
+            return m_defaultModel;
+        }
+
+        CLength ISimulationEnvironmentProvider::getCG(const Aviation::CCallsign &callsign) const
+        {
+            QReadLocker l(&m_lockCG);
+            if (!m_cgs.contains(callsign)) { return CLength::null(); }
+            return m_cgs.value(callsign);
+        }
+
+        bool ISimulationEnvironmentProvider::hasCG(const Aviation::CCallsign &callsign) const
+        {
+            QReadLocker l(&m_lockCG);
+            return m_cgs.contains(callsign);
+        }
+
+        ISimulationEnvironmentProvider::ISimulationEnvironmentProvider(const CSimulatorPluginInfo &pluginInfo) : m_simulatorPluginInfo(pluginInfo)
+        { }
+
+        void ISimulationEnvironmentProvider::setNewPluginInfo(const CSimulatorPluginInfo &info, const CAircraftModel &defaultModel)
+        {
+            QWriteLocker l(&m_lockModel);
+            m_simulatorPluginInfo = info;
+            m_defaultModel = defaultModel;
+        }
+
+        void ISimulationEnvironmentProvider::setDefaultModel(const CAircraftModel &defaultModel)
+        {
+            QWriteLocker l(&m_lockModel);
+            m_defaultModel = defaultModel;
+        }
+
+        void ISimulationEnvironmentProvider::clearDefaultModel()
+        {
+            QWriteLocker l(&m_lockModel);
+            m_defaultModel = CAircraftModel();
+        }
+
+        void ISimulationEnvironmentProvider::clearElevations()
         {
             QWriteLocker l(&m_lockElvCoordinates);
             m_elvCoordinates.clear();
         }
 
+        void ISimulationEnvironmentProvider::clearCGs()
+        {
+            QWriteLocker l(&m_lockCG);
+            m_cgs.clear();
+        }
+
+        void ISimulationEnvironmentProvider::clearSimulationEnvironmentData()
+        {
+            this->clearDefaultModel();
+            this->clearElevations();
+            this->clearCGs();
+        }
+
         CElevationPlane CSimulationEnvironmentAware::findClosestElevationWithinRange(const ICoordinateGeodetic &reference, const PhysicalQuantities::CLength &range)
         {
-            if (!m_simEnvironmentProvider) { return CElevationPlane::null(); }
-            return m_simEnvironmentProvider->findClosestElevationWithinRange(reference, range);
+            if (!this->hasProvider()) { return CElevationPlane::null(); }
+            return this->provider()->findClosestElevationWithinRange(reference, range);
+        }
+
+        CSimulatorPluginInfo CSimulationEnvironmentAware::getSimulatorPluginInfo() const
+        {
+            if (!this->hasProvider()) { return CSimulatorPluginInfo(); }
+            return this->provider()->getSimulatorPluginInfo();
+        }
+
+        CSimulatorInfo CSimulationEnvironmentAware::getSimulatorInfo() const
+        {
+            if (!this->hasProvider()) { return CSimulatorInfo(); }
+            return this->provider()->getSimulatorInfo();
+        }
+
+        CAircraftModel CSimulationEnvironmentAware::getDefaultModel() const
+        {
+            if (!this->hasProvider()) { return CAircraftModel(); }
+            return this->provider()->getDefaultModel();
+        }
+
+        bool CSimulationEnvironmentAware::hasCG(const CCallsign &callsign) const
+        {
+            if (!this->hasProvider()) { return false; }
+            return this->provider()->hasCG(callsign);
         }
     } // namespace
 } // namespace

src/blackmisc/simulation/simulationenvironmentprovider.h

@@ -12,16 +12,22 @@
 #ifndef BLACKMISC_SIMULATION_SIMULATIONENVIRONMENTPROVIDER_H
 #define BLACKMISC_SIMULATION_SIMULATIONENVIRONMENTPROVIDER_H
 
+#include "simulatorplugininfo.h"
+#include "aircraftmodel.h"
+#include "blackmisc/provider.h"
 #include "blackmisc/geo/coordinategeodeticlist.h"
 #include "blackmisc/geo/elevationplane.h"
 
+#include <QMap>
+#include <QObject>
+
 namespace BlackMisc
 {
     namespace Simulation
     {
         //! Direct in memory access to elevation data
         //! \remark we are interested in elevations of airports
-        class BLACKMISC_EXPORT ISimulationEnvironmentProvider
+        class BLACKMISC_EXPORT ISimulationEnvironmentProvider : public IProvider
         {
         public:
             //! All remembered coordiantes
@@ -29,20 +35,55 @@ namespace BlackMisc
             //! \threadsafe
             Geo::CCoordinateGeodeticList getElevationCoordinates() const;
 
-            //! Only keep closest ones
-            //! \threadsafe
-            int cleanUpElevations(const Geo::ICoordinateGeodetic &referenceCoordinate, int maxNumber = MaxElevations);
-
             //! Find closest elevation
             //! \threadsafe
             Geo::CElevationPlane findClosestElevationWithinRange(const Geo::ICoordinateGeodetic &reference, const PhysicalQuantities::CLength &range);
 
+            //! Get the represented plugin
+            //! \threadsafe
+            CSimulatorPluginInfo getSimulatorPluginInfo() const;
+
+            //! Get the represented simulator
+            //! \threadsafe
+            CSimulatorInfo getSimulatorInfo() const;
+
+            //! Default model
+            //! \threadsafe
+            CAircraftModel getDefaultModel() const;
+
+            //! Get CG per callsign, NULL if not found
+            PhysicalQuantities::CLength getCG(const Aviation::CCallsign &callsign) const;
+
+            //! Has a CG?
+            bool hasCG(const Aviation::CCallsign &callsign) const;
+
+        protected:
+            //! Ctor
+            ISimulationEnvironmentProvider(const CSimulatorPluginInfo &pluginInfo);
+
+            //! New plugin info and default model
+            //! \remark normally only used by emulated driver
+            void setNewPluginInfo(const CSimulatorPluginInfo &info, const CAircraftModel &defaultModel);
+
+            //! Default model
+            void setDefaultModel(const CAircraftModel &defaultModel);
+
+            //! Clear default model
+            void clearDefaultModel();
+
+            //! Clear elevations
+            void clearElevations();
+
+            //! Clear CGs
+            void clearCGs();
+
             //! Clear data
             //! \threadsafe
             void clearSimulationEnvironmentData();
 
-        protected:
-            static constexpr int MaxElevations = 1000;  //!< How many elevations we keep
+            //! Only keep closest ones
+            //! \threadsafe
+            int cleanUpElevations(const Geo::ICoordinateGeodetic &referenceCoordinate, int maxNumber = MaxElevations);
 
             //! Remember a given elevation
             //! \threadsafe
@@ -52,28 +93,58 @@ namespace BlackMisc
             //! \threadsafe
             bool rememberGroundElevation(const Geo::CElevationPlane &elevationPlane) ;
 
+            //! Insert or replace a CG
+            //! \remark passing a NULL value will remove the CG
+            //! \threadsafe
+            bool insertCG(const PhysicalQuantities::CLength &cg, const Aviation::CCallsign &cs);
+
+            //! Remove a CG
+            //! \threadsafe
+            int removeCG(const Aviation::CCallsign &cs);
+
+            static constexpr int MaxElevations = 1000;  //!< How many elevations we keep
+
         private:
+            CAircraftModel m_defaultModel; //!< default model
+            CSimulatorPluginInfo m_simulatorPluginInfo; //!< info object
             Geo::CCoordinateGeodeticList m_elvCoordinates;
+            QMap<Aviation::CCallsign, PhysicalQuantities::CLength> m_cgs; //! CGs
             mutable QReadWriteLock m_lockElvCoordinates; //!< lock m_coordinates
+            mutable QReadWriteLock m_lockCG; //!< lock CGs
+            mutable QReadWriteLock m_lockModel; //!< lock models
         };
 
         //! Class which can be directly used to access an \sa ISimulationEnvironmentProvider object
-        class BLACKMISC_EXPORT CSimulationEnvironmentAware
+        class BLACKMISC_EXPORT CSimulationEnvironmentAware : public IProviderAware<ISimulationEnvironmentProvider>
         {
         public:
-            //! Elevations, can be changed over time as it comes from simulator
-            void setSimulationEnvironmentProvider(ISimulationEnvironmentProvider *provider) { m_simEnvironmentProvider = provider; }
+            //! Set the provider
+            void setSimulationEnvironmentProvider(ISimulationEnvironmentProvider *provider) { this->setProvider(provider); }
 
-            //! Find closest elevation
+            //! \copydoc ISimulationEnvironmentProvider::findClosestElevationWithinRange
             Geo::CElevationPlane findClosestElevationWithinRange(const Geo::ICoordinateGeodetic &reference, const PhysicalQuantities::CLength &range);
 
+            //! \copydoc ISimulationEnvironmentProvider::getSimulatorPluginInfo
+            CSimulatorPluginInfo getSimulatorPluginInfo() const;
+
+            //! \copydoc ISimulationEnvironmentProvider::getSimulatorPluginInfo
+            CSimulatorInfo getSimulatorInfo() const;
+
+            //! \copydoc ISimulationEnvironmentProvider::getDefaultModel
+            CAircraftModel getDefaultModel() const;
+
+            //! \copydoc ISimulationEnvironmentProvider::getCG
+            PhysicalQuantities::CLength getCG(const Aviation::CCallsign &callsign) const;
+
+            //! \copydoc ISimulationEnvironmentProvider::hasCG
+            bool hasCG(const Aviation::CCallsign &callsign) const;
+
         protected:
             //! Default constructor
             CSimulationEnvironmentAware() {}
 
             //! Constructor
-            CSimulationEnvironmentAware(ISimulationEnvironmentProvider *simEnvProvider) : m_simEnvironmentProvider(simEnvProvider) { Q_ASSERT(simEnvProvider); }
-            ISimulationEnvironmentProvider *m_simEnvironmentProvider = nullptr; //!< access to object
+            CSimulationEnvironmentAware(ISimulationEnvironmentProvider *simEnvProvider) : IProviderAware(simEnvProvider) { Q_ASSERT(simEnvProvider); }
         };
     } // namespace
 } // namespace