airspaceanalyzer.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2015 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_CORE_AIRSPACE_ANALYZER_H
#define SWIFT_CORE_AIRSPACE_ANALYZER_H
 
#include <atomic>
#include <chrono>
 
#include <QHash>
#include <QReadWriteLock>
#include <QtGlobal>
 
#include "core/fsd/fsdclient.h"
#include "core/swiftcoreexport.h"
#include "misc/aviation/atcstation.h"
#include "misc/geo/coordinategeodetic.h"
#include "misc/network/connectionstatus.h"
#include "misc/pq/frequency.h"
#include "misc/pq/length.h"
#include "misc/pq/units.h"
#include "misc/simulation/airspaceaircraftsnapshot.h"
#include "misc/simulation/ownaircraftprovider.h"
#include "misc/simulation/remoteaircraftprovider.h"
#include "misc/threadedtimer.h"
#include "misc/worker.h"
 
namespace swift::misc::aviation
{
    class CAircraftSituation;
    class CCallsign;
    class CTransponder;
} // namespace swift::misc::aviation
 
namespace swift::core
{
    class CAirspaceMonitor;
 
    class SWIFT_CORE_EXPORT CAirspaceAnalyzer :
        public swift::misc::CContinuousWorker,
        public swift::misc::simulation::COwnAircraftAware,
        public swift::misc::simulation::CRemoteAircraftAware
    {
        Q_OBJECT
 
    public:
        using CCallsignTimestampSet = QHash<swift::misc::aviation::CCallsign, qint64>;
 
        CAirspaceAnalyzer(swift::misc::simulation::IOwnAircraftProvider *ownAircraftProvider,
                          fsd::CFSDClient *fsdClient, CAirspaceMonitor *airspaceMonitorParent);
 
        ~CAirspaceAnalyzer() override = default;
 
        CAirspaceAnalyzer(const CAirspaceAnalyzer &) = delete;
 
        CAirspaceAnalyzer &operator=(const CAirspaceAnalyzer &) = delete;
 
        CAirspaceAnalyzer(CAirspaceAnalyzer &&) = delete;
 
        CAirspaceAnalyzer &operator=(CAirspaceAnalyzer &&) = delete;
 
        swift::misc::simulation::CAirspaceAircraftSnapshot getLatestAirspaceAircraftSnapshot() const;
 
        void
        setSimulatorRenderRestrictionsChanged(bool restricted, bool enabled, int maxAircraft,
                                              const swift::misc::physical_quantities::CLength &maxRenderedDistance);
 
        void setEnabledWatchdog(bool enabled) { m_enabledWatchdog = enabled; }
 
        void clear();
 
    signals:
        void timeoutAircraft(const swift::misc::aviation::CCallsign &callsign);
 
        void timeoutAtc(const swift::misc::aviation::CCallsign &callsign);
 
        void airspaceAircraftSnapshot(const swift::misc::simulation::CAirspaceAircraftSnapshot &snapshot);
 
    private:
        void watchdogRemoveAircraftCallsign(const swift::misc::aviation::CCallsign &callsign);
 
        void watchdogRemoveAtcCallsign(const swift::misc::aviation::CCallsign &callsign);
 
        void watchdogTouchAircraftCallsign(const swift::misc::aviation::CAircraftSituation &situation);
 
        void watchdogTouchAtcCallsign(const swift::misc::aviation::CCallsign &callsign,
                                      const swift::misc::physical_quantities::CFrequency &frequency,
                                      const swift::misc::geo::CCoordinateGeodetic &position,
                                      const swift::misc::physical_quantities::CLength &range);
 
        void onConnectionStatusChanged(swift::misc::network::CConnectionStatus oldStatus,
                                       swift::misc::network::CConnectionStatus newStatus);
 
        void onNetworkPositionUpdate(const swift::misc::aviation::CAircraftSituation &situation,
                                     const swift::misc::aviation::CTransponder &transponder);
 
        void onAtcStationDisconnected(const swift::misc::aviation::CAtcStation &station);
 
        void onTimeout();
 
        void watchdogCheckTimeouts();
 
        void analyzeAirspace();
 
        // watchdog
        CCallsignTimestampSet m_aircraftCallsignTimestamps; 
        CCallsignTimestampSet m_atcCallsignTimestamps; 
        std::chrono::seconds m_timeoutAircraft { 15 }; 
        std::chrono::seconds m_timeoutAtc { 50 }; 
        qint64 m_lastWatchdogCallMsSinceEpoch; 
        qint64 m_doNotRunAgainBefore = -1; 
        std::atomic_bool m_enabledWatchdog { true }; 
        misc::CThreadedTimer m_updateTimer; 
 
        // snapshot
        swift::misc::simulation::CAirspaceAircraftSnapshot m_latestAircraftSnapshot;
        bool m_simulatorRenderedAircraftRestricted = false;
        bool m_simulatorRenderingEnabled = true;
        int m_simulatorMaxRenderedAircraft = -1;
        swift::misc::physical_quantities::CLength m_simulatorMaxRenderedDistance { 0.0, nullptr };
        mutable QReadWriteLock m_lockSnapshot; 
        mutable QReadWriteLock m_lockRestrictions; 
    };
} // namespace swift::core
 
#endif // SWIFT_CORE_AIRSPACE_ANALYZER_H