refs #452 signals in reader classes. adjusted METAR reader

* renamed to connectDataReadSignal
* removed unused individual signals, e.g. vatsimMetarsRead -> replace by data read signal + entity flag
* added data in METAR class (kept there, not in airspace monitor) -> reader aware

src/blackcore/airspace_monitor.cpp

@@ -63,9 +63,8 @@ namespace BlackCore
         Q_ASSERT_X(webDataReader, Q_FUNC_INFO, "Missing data reader");
         if (webDataReader)
         {
-            this->connect(webDataReader->getBookingReader(), &CVatsimBookingReader::dataRead, this, &CAirspaceMonitor::ps_receivedBookings);
-            this->connect(webDataReader->getDataFileReader(), &CVatsimDataFileReader::dataRead, this, &CAirspaceMonitor::ps_receivedDataFile);
-            this->connect(webDataReader->getMetarReader(), &CVatsimMetarReader::dataRead, this, &CAirspaceMonitor::ps_updateMetars);
+            this->connect(webDataReader->getBookingReader(), &CVatsimBookingReader::atcBookingsRead, this, &CAirspaceMonitor::ps_receivedBookings);
+            this->connect(webDataReader->getDataFileReader(), &CVatsimDataFileReader::dataFileRead, this, &CAirspaceMonitor::ps_receivedDataFile);
         }
 
         // Force snapshot in the main event loop
@@ -335,11 +334,6 @@ namespace BlackCore
         return m_otherClients;
     }
 
-    CMetar CAirspaceMonitor::getMetar(const BlackMisc::Aviation::CAirportIcaoCode &airportIcaoCode)
-    {
-        return m_metars.findFirstByOrDefault(&CMetar::getAirportIcaoCode, airportIcaoCode);
-    }
-
     CAtcStation CAirspaceMonitor::getAtcStationForComUnit(const CComSystem &comSystem)
     {
         CAtcStation station;
@@ -391,7 +385,6 @@ namespace BlackCore
 
     void CAirspaceMonitor::clear()
     {
-        m_metars.clear();
         m_flightPlanCache.clear();
         m_modelCache.clear();
 
@@ -606,12 +599,6 @@ namespace BlackCore
         }
     }
 
-    void CAirspaceMonitor::ps_updateMetars(const CMetarSet &metars)
-    {
-        Q_ASSERT(BlackCore::isCurrentThreadObjectThread(this));
-        m_metars = metars;
-    }
-
     void CAirspaceMonitor::ps_sendReadyForModelMatching(const CCallsign &callsign, int trial)
     {
         // some checks for special conditions, e.g. logout -> empty list, but still signals pending

src/blackcore/airspace_monitor.h

@@ -123,9 +123,6 @@ namespace BlackCore
         //! Returns a list of other clients corresponding to the given callsigns
         BlackMisc::Network::CClientList getOtherClientsForCallsigns(const BlackMisc::Aviation::CCallsignSet &callsigns) const;
 
-        //! Returns a METAR for the given airport, if available
-        BlackMisc::Weather::CMetar getMetar(const BlackMisc::Aviation::CAirportIcaoCode &airportIcaoCode);
-
         //! Returns the current online ATC stations
         BlackMisc::Aviation::CAtcStationList getAtcStationsOnline() const { return m_atcStationsOnline; }
 
@@ -213,7 +210,6 @@ namespace BlackCore
         BlackMisc::Aviation::CAtcStationList           m_atcStationsBooked;
         BlackMisc::Network::CClientList                m_otherClients;
         BlackMisc::Simulation::CSimulatedAircraftList  m_aircraftInRange; //!< aircraft, thread safe access required
-        BlackMisc::Weather::CMetarSet                  m_metars;
 
         // hashs, because not sorted by key but keeping order
         CSituationsPerCallsign m_situationsByCallsign; //!< situations, for performance reasons per callsign, thread safe access required
@@ -284,7 +280,6 @@ namespace BlackCore
         void ps_frequencyReceived(const BlackMisc::Aviation::CCallsign &callsign, const BlackMisc::PhysicalQuantities::CFrequency &frequency);
         void ps_receivedBookings(const BlackMisc::Aviation::CAtcStationList &bookedStations);
         void ps_receivedDataFile();
-        void ps_updateMetars(const BlackMisc::Weather::CMetarSet &metars);
         void ps_aircraftConfigReceived(const BlackMisc::Aviation::CCallsign &callsign, const QJsonObject &jsonObject, bool isFull);
         void ps_aircraftInterimUpdateReceived(const BlackMisc::Aviation::CAircraftSituation &situation);
         void ps_sendInterimPositions();

src/blackcore/vatsimbookingreader.cpp

@@ -10,6 +10,7 @@
 #include "blackmisc/sequence.h"
 #include "blackmisc/aviation/atcstation.h"
 #include "blackmisc/network/user.h"
+#include "blackmisc/network/entityflags.h"
 #include "blackmisc/logmessage.h"
 #include "vatsimbookingreader.h"
 
@@ -146,7 +147,8 @@ namespace BlackCore
                     bookedStations.push_back(bookedStation);
                 }
                 this->setUpdateTimestamp(updateTimestamp); // thread safe update
-                emit this->dataRead(bookedStations);
+                emit this->atcBookingsRead(bookedStations);
+                emit this->dataRead(CEntityFlags::BookingEntity, CEntityFlags::ReadFinished, bookedStations.size());
             } // node
         }
         else
@@ -154,6 +156,7 @@ namespace BlackCore
             // network error
             CLogMessage(this).warning("Reading bookings failed %1 %2") << nwReply->errorString() << nwReply->url().toString();
             nwReply->abort();
+            emit this->dataRead(CEntityFlags::BookingEntity, CEntityFlags::ReadFailed, 0);
         }
     } // method
 

src/blackcore/vatsimbookingreader.h

@@ -37,7 +37,10 @@ namespace BlackCore
 
     signals:
         //! Bookings have been read and converted to BlackMisc::Aviation::CAtcStationList
-        void dataRead(const BlackMisc::Aviation::CAtcStationList &bookedStations);
+        void atcBookingsRead(const BlackMisc::Aviation::CAtcStationList &bookedStations);
+
+        //! Data have been read
+        void dataRead(BlackMisc::Network::CEntityFlags::Entity entity, BlackMisc::Network::CEntityFlags::ReadState state, int number);
 
     private slots:
         //! Bookings have been read
@@ -50,7 +53,7 @@ namespace BlackCore
     private:
         QString m_serviceUrl; //!< URL of the service
         QNetworkAccessManager *m_networkManager = nullptr;
-
     };
 }
+
 #endif // guard

src/blackcore/vatsimdatafilereader.cpp

@@ -11,6 +11,7 @@
 #include "blackmisc/aviation/atcstation.h"
 #include "blackmisc/network/user.h"
 #include "blackmisc/network/server.h"
+#include "blackmisc/network/entityflags.h"
 #include "blackmisc/logmessage.h"
 #include "vatsimdatafilereader.h"
 
@@ -362,13 +363,15 @@ namespace BlackCore
             }
 
             // data read finished
-            emit this->dataRead(lines.count());
+            emit this->dataFileRead(lines.count());
+            emit this->dataRead(CEntityFlags::VatsimDataFile, CEntityFlags::ReadFinished, lines.count());
         }
         else
         {
             // network error
             CLogMessage(this).warning("Reading VATSIM data file failed %1 %2") << nwReply->errorString() << nwReply->url().toString();
             nwReply->abort();
+            emit this->dataRead(CEntityFlags::VatsimDataFile, CEntityFlags::ReadFailed, 0);
         }
     }
 

src/blackcore/vatsimdatafilereader.h

@@ -106,7 +106,10 @@ namespace BlackCore
 
     signals:
         //! Data have been read
-        void dataRead(int lines);
+        void dataFileRead(int lines);
+
+        //! Data have been read
+        void dataRead(BlackMisc::Network::CEntityFlags::Entity entity, BlackMisc::Network::CEntityFlags::ReadState state, int number);
 
     private slots:
         //! Data have been read, parse VATSIM file
@@ -142,6 +145,6 @@ namespace BlackCore
         static Section currentLineToSection(const QString &currentLine);
 
     };
-}
+} // ns
 
 #endif // guard

src/blackcore/vatsimmetarreader.cpp

@@ -8,12 +8,16 @@
  */
 
 #include "vatsimmetarreader.h"
+#include "blackmisc/network/entityflags.h"
 #include "blackmisc/sequence.h"
 #include "blackmisc/logmessage.h"
 #include <QTextStream>
 #include <QFile>
+#include <QReadLocker>
+#include <QWriteLocker>
 
 using namespace BlackMisc;
+using namespace BlackMisc::Network;
 using namespace BlackMisc::Weather;
 
 namespace BlackCore
@@ -34,6 +38,24 @@ namespace BlackCore
         Q_UNUSED(s);
     }
 
+    CMetarSet CVatsimMetarReader::getMetars() const
+    {
+        QReadLocker l(&m_lock);
+        return m_metars;
+    }
+
+    CMetar CVatsimMetarReader::getMetarForAirport(const Aviation::CAirportIcaoCode &icao) const
+    {
+        QReadLocker l(&m_lock);
+        return m_metars.getMetarForAirport(icao);
+    }
+
+    int CVatsimMetarReader::getMetarsCount() const
+    {
+        QReadLocker l(&m_lock);
+        return m_metars.size();
+    }
+
     void CVatsimMetarReader::ps_readMetars()
     {
         this->threadAssertCheck();
@@ -85,19 +107,26 @@ namespace BlackCore
                 }
             }
 
+            {
+                QWriteLocker l(&m_lock);
+                m_metars = metars;
+            }
+
             // I could use those for logging, etc.
             Q_UNUSED(invalidMetars);
             if (invalidLineCount > 0)
             {
                 CLogMessage(this).warning("Reading METARs failed for %1 entries") << invalidLineCount;
             }
-            emit dataRead(metars);
+            emit metarsRead(metars);
+            emit dataRead(CEntityFlags::MetarEntity, CEntityFlags::ReadFinished, metars.size());
         }
         else
         {
             // network error
             CLogMessage(this).warning("Reading METARs failed %1 %2") << nwReply->errorString() << nwReply->url().toString();
             nwReply->abort();
+            emit dataRead(CEntityFlags::MetarEntity, CEntityFlags::ReadFailed, 0);
         }
     } // method
 

src/blackcore/vatsimmetarreader.h

@@ -36,9 +36,24 @@ namespace BlackCore
         //! Read / re-read bookings
         void readInBackgroundThread();
 
+        //! Get METARs
+        //! \threadsafe
+        virtual BlackMisc::Weather::CMetarSet getMetars() const;
+
+        //! Get METAR for airport
+        //! \threadsafe
+        virtual BlackMisc::Weather::CMetar getMetarForAirport(const BlackMisc::Aviation::CAirportIcaoCode &icao) const;
+
+        //! Get METARs count
+        //! \threadsafe
+        virtual int getMetarsCount() const;
+
     signals:
         //! METARs have been read and converted to BlackMisc::Weather::CMetarSet
-        void dataRead(const BlackMisc::Weather::CMetarSet &metars);
+        void metarsRead(const BlackMisc::Weather::CMetarSet &metars);
+
+        //! Data have been read
+        void dataRead(BlackMisc::Network::CEntityFlags::Entity entity, BlackMisc::Network::CEntityFlags::ReadState state, int number);
 
     private slots:
         //! Decode METARs
@@ -49,9 +64,10 @@ namespace BlackCore
         void ps_readMetars();
 
     private:
-        QString m_metarUrl; //!< URL of the service
-        QNetworkAccessManager *m_networkManager = nullptr;
+        QString                           m_metarUrl; //!< URL of the service
+        QNetworkAccessManager            *m_networkManager = nullptr;
         BlackMisc::Weather::CMetarDecoder m_metarDecoder;
+        BlackMisc::Weather::CMetarSet     m_metars;
     };
 }
 #endif // guard

src/blackcore/webdataservices.cpp

@@ -18,6 +18,7 @@
 #include "blackmisc/logmessage.h"
 #include "blackmisc/worker.h"
 
+using namespace BlackCore;
 using namespace BlackCore::Settings;
 using namespace BlackMisc;
 using namespace BlackMisc::Simulation;
@@ -35,40 +36,7 @@ namespace BlackCore
         this->initWriters();
     }
 
-    QList<QMetaObject::Connection> CWebDataServices::connectVatsimDataSignals(QObject *receiver,
-            std::function<void(int)> bookingsRead,
-            std::function<void(int)> dataFileRead,
-            std::function<void(int)> metarsRead)
-    {
-        // bind does not allow to define connection type
-        // so anything in its own thread will be sent with this thread affinity
-        Q_ASSERT_X(receiver, Q_FUNC_INFO, "Missing receiver");
-        QList<QMetaObject::Connection> cl;
-
-        if (m_readerFlags.testFlag(CWebReaderFlags::WebReaderFlags::VatsimBookingReader))
-        {
-            QMetaObject::Connection c1 = connect(this, &CWebDataServices::vatsimBookingsRead, receiver, bookingsRead);
-            Q_ASSERT_X(c1, Q_FUNC_INFO, "connect failed (bookings)");
-            cl.append(c1);
-        }
-
-        if (m_readerFlags.testFlag(CWebReaderFlags::WebReaderFlags::VatsimDataReader))
-        {
-            QMetaObject::Connection c2 = connect(this, &CWebDataServices::vatsimDataFileRead, receiver, dataFileRead);
-            Q_ASSERT_X(c2, Q_FUNC_INFO, "connect failed (data)");
-            cl.append(c2);
-        }
-
-        if (m_readerFlags.testFlag(CWebReaderFlags::WebReaderFlags::VatsimMetarReader))
-        {
-            QMetaObject::Connection c3 = connect(this, &CWebDataServices::vatsimMetarsRead, receiver, metarsRead);
-            Q_ASSERT_X(c3, Q_FUNC_INFO, "connect failed (METARs)");
-            cl.append(c3);
-        }
-        return cl;
-    }
-
-    QList<QMetaObject::Connection> CWebDataServices::connectSwiftDatabaseSignals(QObject *receiver, std::function<void(CDbFlags::Entity, CDbFlags::ReadState, int)> dataRead)
+    QList<QMetaObject::Connection> CWebDataServices::connectDataReadSignal(QObject *receiver, std::function<void(CEntityFlags::Entity, CEntityFlags::ReadState, int)> dataRead)
     {
         Q_ASSERT_X(receiver, Q_FUNC_INFO, "Missing receiver");
 
@@ -76,21 +44,45 @@ namespace BlackCore
         // so anything in its own thread will be sent with this thread affinity
         QList<QMetaObject::Connection> cl;
 
-        if (m_readerFlags.testFlag(CWebReaderFlags::WebReaderFlags::IcaoDataReader))
+        if (m_readerFlags.testFlag(CWebReaderFlags::WebReaderFlag::IcaoDataReader))
         {
             Q_ASSERT_X(this->m_icaoDataReader, Q_FUNC_INFO, "Missing reader ICAO");
-            QMetaObject::Connection con = connect(this->m_icaoDataReader, &CIcaoDataReader::readData, receiver, dataRead);
+            QMetaObject::Connection con = connect(this->m_icaoDataReader, &CIcaoDataReader::dataRead, receiver, dataRead);
             Q_ASSERT_X(con, Q_FUNC_INFO, "connect failed ICAO");
             cl.append(con);
         }
 
-        if (m_readerFlags.testFlag(CWebReaderFlags::WebReaderFlags::ModelReader))
+        if (m_readerFlags.testFlag(CWebReaderFlags::WebReaderFlag::ModelReader))
         {
             Q_ASSERT_X(this->m_modelDataReader, Q_FUNC_INFO, "Missing reader models");
-            QMetaObject::Connection con = connect(this->m_modelDataReader, &CModelDataReader::readData, receiver, dataRead);
+            QMetaObject::Connection con = connect(this->m_modelDataReader, &CModelDataReader::dataRead, receiver, dataRead);
             Q_ASSERT_X(con, Q_FUNC_INFO, "connect failed models");
             cl.append(con);
         }
+
+        if (m_readerFlags.testFlag(CWebReaderFlags::WebReaderFlag::VatsimBookingReader))
+        {
+            Q_ASSERT_X(this->m_modelDataReader, Q_FUNC_INFO, "Missing reader bookings");
+            QMetaObject::Connection con = connect(this->m_vatsimBookingReader, &CVatsimBookingReader::dataRead, receiver, dataRead);
+            Q_ASSERT_X(con, Q_FUNC_INFO, "connect failed bookings");
+            cl.append(con);
+        }
+
+        if (m_readerFlags.testFlag(CWebReaderFlags::WebReaderFlag::VatsimDataReader))
+        {
+            Q_ASSERT_X(this->m_vatsimDataFileReader, Q_FUNC_INFO, "Missing reader data file");
+            QMetaObject::Connection con = connect(this->m_vatsimDataFileReader, &CVatsimDataFileReader::dataRead, receiver, dataRead);
+            Q_ASSERT_X(con, Q_FUNC_INFO, "connect failed VATSIM data file");
+            cl.append(con);
+        }
+
+        if (m_readerFlags.testFlag(CWebReaderFlags::WebReaderFlag::VatsimMetarReader))
+        {
+            Q_ASSERT_X(this->m_vatsimMetarReader, Q_FUNC_INFO, "Missing reader bookings");
+            QMetaObject::Connection con = connect(this->m_vatsimMetarReader, &CVatsimMetarReader::dataRead, receiver, dataRead);
+            Q_ASSERT_X(con, Q_FUNC_INFO, "connect failed VATSIM METAR");
+            cl.append(con);
+        }
         return cl;
     }
 
@@ -149,32 +141,32 @@ namespace BlackCore
         return true;
     }
 
-    CDbFlags::Entity CWebDataServices::triggerRead(CDbFlags::Entity whatToRead)
+    CEntityFlags::Entity CWebDataServices::triggerRead(CEntityFlags::Entity whatToRead)
     {
-        CDbFlags::Entity triggeredRead = CDbFlags::NoEntity;
+        CEntityFlags::Entity triggeredRead = CEntityFlags::NoEntity;
         if (m_vatsimDataFileReader)
         {
-            if (whatToRead.testFlag(CDbFlags::VatsimDataFile))
+            if (whatToRead.testFlag(CEntityFlags::VatsimDataFile))
             {
                 m_vatsimDataFileReader->readInBackgroundThread();
-                triggeredRead |= CDbFlags::VatsimDataFile;
+                triggeredRead |= CEntityFlags::VatsimDataFile;
             }
         }
 
         if (m_vatsimBookingReader)
         {
-            if (whatToRead.testFlag(CDbFlags::VatsimBookings))
+            if (whatToRead.testFlag(CEntityFlags::BookingEntity))
             {
                 m_vatsimBookingReader->readInBackgroundThread();
-                triggeredRead |= CDbFlags::VatsimBookings;
+                triggeredRead |= CEntityFlags::BookingEntity;
             }
         }
 
         if (m_icaoDataReader)
         {
-            if (whatToRead.testFlag(CDbFlags::AircraftIcaoEntity) || whatToRead.testFlag(CDbFlags::AirlineIcaoEntity) || whatToRead.testFlag(CDbFlags::CountryEntity))
+            if (whatToRead.testFlag(CEntityFlags::AircraftIcaoEntity) || whatToRead.testFlag(CEntityFlags::AirlineIcaoEntity) || whatToRead.testFlag(CEntityFlags::CountryEntity))
             {
-                CDbFlags::Entity icaoEntities = whatToRead & CDbFlags::AllIcaoAndCountries;
+                CEntityFlags::Entity icaoEntities = whatToRead & CEntityFlags::AllIcaoAndCountries;
                 m_icaoDataReader->readInBackgroundThread(icaoEntities);
                 triggeredRead |= icaoEntities;
             }
@@ -182,9 +174,9 @@ namespace BlackCore
 
         if (m_modelDataReader)
         {
-            if (whatToRead.testFlag(CDbFlags::LiveryEntity) || whatToRead.testFlag(CDbFlags::DistributorEntity) || whatToRead.testFlag(CDbFlags::ModelEntity))
+            if (whatToRead.testFlag(CEntityFlags::LiveryEntity) || whatToRead.testFlag(CEntityFlags::DistributorEntity) || whatToRead.testFlag(CEntityFlags::ModelEntity))
             {
-                CDbFlags::Entity modelEntities = whatToRead & CDbFlags::DistributorLiveryModel;
+                CEntityFlags::Entity modelEntities = whatToRead & CEntityFlags::DistributorLiveryModel;
                 m_modelDataReader->readInBackgroundThread(modelEntities);
                 triggeredRead |= modelEntities;
             }
@@ -336,6 +328,24 @@ namespace BlackCore
         return CCountry();
     }
 
+    CMetarSet CWebDataServices::getMetars() const
+    {
+        if (m_vatsimMetarReader) { return m_vatsimMetarReader->getMetars(); }
+        return CMetarSet();
+    }
+
+    CMetar CWebDataServices::getMetarForAirport(const CAirportIcaoCode &icao) const
+    {
+        if (m_vatsimMetarReader) { return m_vatsimMetarReader->getMetarForAirport(icao); }
+        return CMetar();
+    }
+
+    int CWebDataServices::getMetarsCount() const
+    {
+        if (m_vatsimMetarReader) { return m_vatsimMetarReader->getMetarsCount(); }
+        return 0;
+    }
+
     CAirlineIcaoCode CWebDataServices::getAirlineIcaoCodeForDesignator(const QString &designator) const
     {
         if (m_icaoDataReader) { return m_icaoDataReader->getAirlineIcaoCodeForDesignator(designator); }
@@ -361,10 +371,10 @@ namespace BlackCore
     void CWebDataServices::initReaders(CWebReaderFlags::WebReader flags)
     {
         // 1. VATSIM bookings
-        if (flags.testFlag(CWebReaderFlags::WebReaderFlags::VatsimBookingReader))
+        if (flags.testFlag(CWebReaderFlags::WebReaderFlag::VatsimBookingReader))
         {
             this->m_vatsimBookingReader = new CVatsimBookingReader(this, CGlobalReaderSettings::instance().bookingsUrl());
-            bool c = connect(this->m_vatsimBookingReader, &CVatsimBookingReader::dataRead, this, &CWebDataServices::ps_receivedBookings);
+            bool c = connect(this->m_vatsimBookingReader, &CVatsimBookingReader::atcBookingsRead, this, &CWebDataServices::ps_receivedBookings);
             Q_ASSERT_X(c, Q_FUNC_INFO, "VATSIM booking reader signals");
             Q_UNUSED(c);
             this->m_vatsimBookingReader->start(QThread::LowPriority);
@@ -372,10 +382,10 @@ namespace BlackCore
         }
 
         // 2. VATSIM data file
-        if (flags.testFlag(CWebReaderFlags::WebReaderFlags::VatsimDataReader))
+        if (flags.testFlag(CWebReaderFlags::WebReaderFlag::VatsimDataReader))
         {
             this->m_vatsimDataFileReader = new CVatsimDataFileReader(this, CGlobalReaderSettings::instance().vatsimDataFileUrls());
-            bool c = connect(this->m_vatsimDataFileReader, &CVatsimDataFileReader::dataRead, this, &CWebDataServices::ps_dataFileRead);
+            bool c = connect(this->m_vatsimDataFileReader, &CVatsimDataFileReader::dataFileRead, this, &CWebDataServices::ps_dataFileRead);
             Q_ASSERT_X(c, Q_FUNC_INFO, "VATSIM data reader signals");
             Q_UNUSED(c);
             this->m_vatsimDataFileReader->start(QThread::LowPriority);
@@ -383,10 +393,10 @@ namespace BlackCore
         }
 
         // 3. VATSIM metar data
-        if (flags.testFlag(CWebReaderFlags::WebReaderFlags::VatsimMetarReader))
+        if (flags.testFlag(CWebReaderFlags::WebReaderFlag::VatsimMetarReader))
         {
             this->m_vatsimMetarReader = new CVatsimMetarReader(this, CGlobalReaderSettings::instance().urlVatsimMetars());
-            bool c = connect(this->m_vatsimMetarReader, &CVatsimMetarReader::dataRead, this, &CWebDataServices::ps_receivedMetars);
+            bool c = connect(this->m_vatsimMetarReader, &CVatsimMetarReader::metarsRead, this, &CWebDataServices::ps_receivedMetars);
             Q_ASSERT_X(c, Q_FUNC_INFO, "VATSIM METAR reader signals");
             Q_UNUSED(c);
             this->m_vatsimMetarReader->start(QThread::LowPriority);
@@ -394,21 +404,21 @@ namespace BlackCore
         }
 
         // 4. ICAO data reader
-        if (flags.testFlag(CWebReaderFlags::WebReaderFlags::IcaoDataReader))
+        if (flags.testFlag(CWebReaderFlags::WebReaderFlag::IcaoDataReader))
         {
             bool c;
             this->m_icaoDataReader = new CIcaoDataReader(this, CGlobalReaderSettings::instance().protocolIcaoReader(), CGlobalReaderSettings::instance().serverIcaoReader(), CGlobalReaderSettings::instance().baseUrlIcaoReader());
-            c = connect(this->m_icaoDataReader, &CIcaoDataReader::readData, this, &CWebDataServices::ps_readFromSwiftDb);
+            c = connect(this->m_icaoDataReader, &CIcaoDataReader::dataRead, this, &CWebDataServices::ps_readFromSwiftDb);
             Q_ASSERT_X(c, Q_FUNC_INFO, "ICAO reader signals");
             Q_UNUSED(c);
             this->m_icaoDataReader->start();
         }
 
         // 5. Model reader
-        if (flags.testFlag(CWebReaderFlags::WebReaderFlags::ModelReader))
+        if (flags.testFlag(CWebReaderFlags::WebReaderFlag::ModelReader))
         {
             this->m_modelDataReader = new CModelDataReader(this, CGlobalReaderSettings::instance().protocolModelReader(), CGlobalReaderSettings::instance().serverModelReader(), CGlobalReaderSettings::instance().baseUrlModelReader());
-            bool c = connect(this->m_modelDataReader, &CModelDataReader::readData, this, &CWebDataServices::ps_readFromSwiftDb);
+            bool c = connect(this->m_modelDataReader, &CModelDataReader::dataRead, this, &CWebDataServices::ps_readFromSwiftDb);
             Q_ASSERT_X(c, Q_FUNC_INFO, "Model reader signals");
             Q_UNUSED(c);
             this->m_modelDataReader->start();
@@ -427,25 +437,22 @@ namespace BlackCore
     void CWebDataServices::ps_receivedBookings(const CAtcStationList &stations)
     {
         CLogMessage(this).info("Read %1 ATC bookings from network") << stations.size();
-        emit vatsimBookingsRead(stations.size());
     }
 
     void CWebDataServices::ps_receivedMetars(const CMetarSet &metars)
     {
         CLogMessage(this).info("Read %1 METARs") << metars.size();
-        emit vatsimDataFileRead(metars.size());
     }
 
     void CWebDataServices::ps_dataFileRead(int lines)
     {
         CLogMessage(this).info("Read VATSIM data file, %1 lines") << lines;
-        emit vatsimDataFileRead(lines);
     }
 
-    void CWebDataServices::ps_readFromSwiftDb(CDbFlags::Entity entity, CDbFlags::ReadState state, int number)
+    void CWebDataServices::ps_readFromSwiftDb(CEntityFlags::Entity entity, CEntityFlags::ReadState state, int number)
     {
-        CLogMessage(this).info("Read data %1 %3 %2") << CDbFlags::flagToString(entity) << number << CDbFlags::flagToString(state);
-        emit readSwiftDbData(entity, state, number);
+        CLogMessage(this).info("Read data %1 %3 %2") << CEntityFlags::flagToString(entity) << number << CEntityFlags::flagToString(state);
+        // emit readSwiftDbData(entity, state, number);
     }
 
     void CWebDataServices::readAllInBackground(int delayMs)
@@ -462,8 +469,8 @@ namespace BlackCore
             // only readers requested will be read
             if (this->m_vatsimBookingReader) {this->m_vatsimBookingReader->readInBackgroundThread(); }
             if (this->m_vatsimDataFileReader) this->m_vatsimDataFileReader->readInBackgroundThread();
-            if (this->m_icaoDataReader) { this->m_icaoDataReader->readInBackgroundThread(CDbFlags::AllIcaoAndCountries); }
-            if (this->m_modelDataReader) { this->m_modelDataReader->readInBackgroundThread(CDbFlags::DistributorLiveryModel); }
+            if (this->m_icaoDataReader) { this->m_icaoDataReader->readInBackgroundThread(CEntityFlags::AllIcaoAndCountries); }
+            if (this->m_modelDataReader) { this->m_modelDataReader->readInBackgroundThread(CEntityFlags::DistributorLiveryModel); }
         }
     }
 

src/blackcore/webdataservices.h

@@ -73,19 +73,13 @@ namespace BlackCore
 
         // ------------------------ provider functionality ------------------------------
 
-        //! \copydoc IWebDataReaderProvider::connectVatsimDataSignals
+        //! \copydoc IWebDataReaderProvider::connectDataReadSignal
         //! \ingroup webdatareaderprovider
-        virtual QList<QMetaObject::Connection> connectVatsimDataSignals(
+        virtual QList<QMetaObject::Connection> connectDataReadSignal(
             QObject *receiver,
-            std::function<void(int)> bookingsRead, std::function<void(int)> dataFileRead, std::function<void(int)> metarsRead) override;
+            std::function<void (BlackMisc::Network::CEntityFlags::Entity, BlackMisc::Network::CEntityFlags::ReadState, int)> dataRead) override;
 
-        //! \copydoc IWebDataReaderProvider::connectSwiftDatabaseSignals
-        //! \ingroup webdatareaderprovider
-        virtual QList<QMetaObject::Connection> connectSwiftDatabaseSignals(
-            QObject *receiver,
-            std::function<void (BlackMisc::Network::CDbFlags::Entity, BlackMisc::Network::CDbFlags::ReadState, int)> dataRead) override;
-
-        //! \copydoc IWebDataReaderProvider::connectSwiftDatabaseSignals
+        //! \copydoc IWebDataReaderProvider::triggerRead
         //! \ingroup webdatareaderprovider
         virtual BlackMisc::Network::CEntityFlags::Entity triggerRead(BlackMisc::Network::CEntityFlags::Entity whatToRead) override;
 
@@ -197,6 +191,18 @@ namespace BlackCore
         //! \ingroup webdatareaderprovider
         virtual BlackMisc::CCountry getCountryForIsoCode(const QString &iso) const override;
 
+        //! \copydoc IWebDataReaderProvider::getMetars
+        //! \ingroup webdatareaderprovider
+        virtual BlackMisc::Weather::CMetarSet getMetars() const override;
+
+        //! \copydoc IWebDataReaderProvider::getMetarForAirport
+        //! \ingroup webdatareaderprovider
+        virtual BlackMisc::Weather::CMetar getMetarForAirport(const BlackMisc::Aviation::CAirportIcaoCode &icao) const override;
+
+        //! \copydoc IWebDataReaderProvider::getMetarForAirport
+        //! \ingroup webdatareaderprovider
+        virtual int getMetarsCount() const override;
+
         //! \copydoc IWebDataReaderProvider::getUsersForCallsign
         //! \ingroup webdatareaderprovider
         virtual BlackMisc::Network::CUserList getUsersForCallsign(const BlackMisc::Aviation::CCallsign &callsign) const override;
@@ -226,17 +232,9 @@ namespace BlackCore
         void readAllInBackground(int delayMs);
 
     signals:
-        //! Data file read
-        void vatsimDataFileRead(int lines);
-
-        //! Bookings read
-        void vatsimBookingsRead(int number);
-
-        //! METARs read
-        void vatsimMetarsRead(int number);
-
-        //! Combined read signal
-        void readSwiftDbData(BlackMisc::Network::CEntityFlags::Entity entity, BlackMisc::Network::CEntityFlags::ReadState state, int number);
+        //
+        // Consider to use the connect method of the provider to connect by entity
+        //
 
         //! Model has been written
         void modelWritten(const BlackMisc::Simulation::CAircraftModel &model);