flightplan.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_AVIATION_FLIGHTPLAN_H
#define SWIFT_MISC_AVIATION_FLIGHTPLAN_H
 
#include <QDateTime>
#include <QMetaType>
#include <QString>
#include <QTime>
#include <QtGlobal>
 
#include "misc/aviation/aircrafticaocode.h"
#include "misc/aviation/airlineicaocode.h"
#include "misc/aviation/airporticaocode.h"
#include "misc/aviation/altitude.h"
#include "misc/aviation/callsign.h"
#include "misc/aviation/flightplanaircraftinfo.h"
#include "misc/aviation/selcal.h"
#include "misc/logcategories.h"
#include "misc/metaclass.h"
#include "misc/network/url.h"
#include "misc/network/voicecapabilities.h"
#include "misc/pq/speed.h"
#include "misc/pq/time.h"
#include "misc/pq/units.h"
#include "misc/statusmessagelist.h"
#include "misc/swiftmiscexport.h"
#include "misc/timestampbased.h"
#include "misc/valueobject.h"
 
SWIFT_DECLARE_VALUEOBJECT_MIXINS(swift::misc::Aviation, CFlightPlanRemarks)
SWIFT_DECLARE_VALUEOBJECT_MIXINS(swift::misc::Aviation, CFlightPlan)
 
namespace swift::misc::aviation
{
    class SWIFT_MISC_EXPORT CFlightPlanRemarks : public CValueObject<CFlightPlanRemarks>
    {
    public:
        CFlightPlanRemarks();
 
        CFlightPlanRemarks(const QString &remarks, bool parse = true);
 
        CFlightPlanRemarks(const QString &remarks, network::CVoiceCapabilities voiceCapabilities, bool parse = true);
 
        const QString &getRemarks() const { return m_remarks; }
 
        const QString &getRadioTelephony() const { return m_radioTelephony; }
 
        const QString &getFlightOperator() const { return m_flightOperator; }
 
        const CAirlineIcaoCode &getAirlineIcao() const { return m_airlineIcao; }
 
        const CSelcal &getSelcalCode() const { return m_selcalCode; }
 
        bool setSelcalCode(const QString &selcal);
 
        const CCallsign &getRegistration() const { return m_registration; }
 
        const network::CVoiceCapabilities &getVoiceCapabilities() const { return m_voiceCapabilities; }
 
        void setVoiceCapabilitiesByText(const QString &text);
 
        void setVoiceCapabilities(const network::CVoiceCapabilities &capabilities);
 
        bool hasAnyParsedRemarks() const;
 
        bool hasParsedAirlineRemarks() const;
 
        void parseFlightPlanRemarks(bool force = false);
 
        bool hasValidAirlineIcao() const { return m_airlineIcao.hasValidDesignator(); }
 
        bool isEmpty() const { return m_remarks.isEmpty(); }
 
        bool isParsed() const { return m_isParsed; }
 
        QString convertToQString(bool i18n = false) const;
 
        static QString textToVoiceCapabilitiesRemarks(const QString &text);
 
        static QString replaceVoiceCapabilities(const QString &newCapRemarks, const QString &oldRemarks);
 
        static QString cleanRemarks(const QString &remarksIn);
 
    private:
        QString m_remarks; 
        QString m_radioTelephony; 
        QString m_flightOperator; 
        CCallsign m_registration; 
        CSelcal m_selcalCode; 
        CAirlineIcaoCode m_airlineIcao; 
        network::CVoiceCapabilities m_voiceCapabilities; 
        bool m_isParsed = false; 
 
        SWIFT_METACLASS(
            CFlightPlanRemarks,
            SWIFT_METAMEMBER(remarks, 0, DisabledForComparison),
            SWIFT_METAMEMBER(radioTelephony),
            SWIFT_METAMEMBER(flightOperator),
            SWIFT_METAMEMBER(airlineIcao),
            SWIFT_METAMEMBER(selcalCode),
            SWIFT_METAMEMBER(registration),
            SWIFT_METAMEMBER(isParsed),
            SWIFT_METAMEMBER(voiceCapabilities));
 
        static QString getRemark(const QString &remarks, const QString &marker);
 
        static QString replaceRemark(const QString &remarks, const QString &marker, const QString &newRemark);
    };
 
    class SWIFT_MISC_EXPORT CFlightPlan : public CValueObject<CFlightPlan>, public ITimestampBased
    {
    public:
        static const QStringList &getLogCategories();
 
        enum FlightRules
        {
            VFR = 0, 
            IFR, 
            SVFR, 
            DVFR, 
            UNKNOWN 
        };
 
        enum ColumnIndex
        {
            IndexCallsign = CPropertyIndexRef::GlobalIndexCFlightPlan,
            IndexOriginAirportIcao,
            IndexDestinationAirportIcao,
            IndexAlternateAirportIcao,
            IndexRemarks
        };
 
        //  https://forums.vatsim.net/viewtopic.php?f=6&t=63416
        static constexpr int MaxRemarksLength = 512; 
        static constexpr int MaxRouteLength = 512; 
        static constexpr int MaxRouteAndRemarksLength = 624; 
 
        CFlightPlan() = default;
 
        CFlightPlan(const CCallsign &callsign, const CFlightPlanAircraftInfo &aircraftInfo,
                    const CAirportIcaoCode &originAirportIcao, const CAirportIcaoCode &destinationAirportIcao,
                    const CAirportIcaoCode &alternateAirportIcao, const QDateTime &takeoffTimePlanned,
                    const QDateTime &takeoffTimeActual, const physical_quantities::CTime &enrouteTime,
                    const physical_quantities::CTime &fuelTime, const CAltitude &cruiseAltitude,
                    const physical_quantities::CSpeed &cruiseTrueAirspeed, FlightRules flightRules,
                    const QString &route, const QString &remarks);
 
        void setCallsign(const CCallsign &callsign);
 
        void setAircraftInfo(const CFlightPlanAircraftInfo &aircraftInfo);
 
        void setOriginAirportIcao(const QString &originAirportIcao) { m_originAirportIcao = originAirportIcao; }
 
        void setOriginAirportIcao(const CAirportIcaoCode &originAirportIcao)
        {
            m_originAirportIcao = originAirportIcao;
        }
 
        void setDestinationAirportIcao(const QString &destinationAirportIcao)
        {
            m_destinationAirportIcao = destinationAirportIcao;
        }
 
        void setDestinationAirportIcao(const CAirportIcaoCode &destinationAirportIcao)
        {
            m_destinationAirportIcao = destinationAirportIcao;
        }
 
        void setAlternateAirportIcao(const QString &alternateAirportIcao)
        {
            m_alternateAirportIcao = alternateAirportIcao;
        }
 
        void setAlternateAirportIcao(const CAirportIcaoCode &alternateAirportIcao)
        {
            m_alternateAirportIcao = alternateAirportIcao;
        }
 
        void setTakeoffTimePlanned(const QDateTime &takeoffTimePlanned);
 
        void setTakeoffTimePlanned(const QString &time)
        {
            m_takeoffTimePlanned = QDateTime::currentDateTimeUtc();
            m_takeoffTimePlanned.setTime(QTime::fromString(time, "hh:mm"));
        }
 
        void setTakeoffTimeActual(const QDateTime &takeoffTimeActual);
 
        void setTakeoffTimeActual(const QString &time)
        {
            m_takeoffTimeActual = QDateTime::currentDateTimeUtc();
            m_takeoffTimeActual.setTime(QTime::fromString(time, "hh:mm"));
        }
 
        void setEnrouteTime(const physical_quantities::CTime &enrouteTime)
        {
            m_enrouteTime = enrouteTime;
            m_enrouteTime.switchUnit(swift::misc::physical_quantities::CTimeUnit::hrmin());
        }
 
        void setFuelTime(const physical_quantities::CTime &fuelTime)
        {
            m_fuelTime = fuelTime;
            m_fuelTime.switchUnit(swift::misc::physical_quantities::CTimeUnit::hrmin());
        }
 
        void setFuelTime(const QString &fuelTime) { m_fuelTime = physical_quantities::CTime(fuelTime); }
 
        void setCruiseAltitude(const CAltitude &cruiseAltitude)
        {
            m_cruiseAltitude = cruiseAltitude;
            m_cruiseAltitudeString.clear();
        }
 
        void setCruiseAltitudeString(const QString &altitudeString) { m_cruiseAltitudeString = altitudeString; }
 
        void setCruiseTrueAirspeed(const physical_quantities::CSpeed &cruiseTrueAirspeed)
        {
            m_cruiseTrueAirspeed = cruiseTrueAirspeed;
        }
 
        void setFlightRule(FlightRules flightRule) { m_flightRules = flightRule; }
 
        void setFlightRule(const QString &flightRule);
 
        void setRoute(const QString &route);
 
        void setRemarks(const QString &remarks);
 
        void setVoiceCapabilities(const QString &capabilities);
 
        void setWhenLastSentOrLoaded(const QDateTime &dateTime) { this->setUtcTimestamp(dateTime); }
 
        const CCallsign &getCallsign() const { return m_callsign; }
 
        bool hasCallsign() const { return !m_callsign.isEmpty(); }
 
        const CAirportIcaoCode &getOriginAirportIcao() const { return m_originAirportIcao; }
 
        const CAirportIcaoCode &getDestinationAirportIcao() const { return m_destinationAirportIcao; }
 
        const CAirportIcaoCode &getAlternateAirportIcao() const { return m_alternateAirportIcao; }
 
        const QDateTime &getTakeoffTimePlanned() const { return m_takeoffTimePlanned; }
 
        QString getTakeoffTimePlannedHourMin() const;
 
        const QDateTime &getTakeoffTimeActual() const { return m_takeoffTimeActual; }
 
        QString getTakeoffTimeActualHourMin() const;
 
        const physical_quantities::CTime &getEnrouteTime() const { return m_enrouteTime; }
 
        QString getEnrouteTimeHourMin() const
        {
            return m_enrouteTime.valueRoundedWithUnit(physical_quantities::CTimeUnit::hrmin());
        }
 
        const physical_quantities::CTime &getFuelTime() const { return m_fuelTime; }
 
        QString getFuelTimeHourMin() const
        {
            return m_fuelTime.valueRoundedWithUnit(physical_quantities::CTimeUnit::hrmin());
        }
 
        const CAltitude &getCruiseAltitude() const { return m_cruiseAltitude; }
 
        const QString &getCruiseAltitudeString() const { return m_cruiseAltitudeString; }
 
        const physical_quantities::CSpeed &getCruiseTrueAirspeed() const { return m_cruiseTrueAirspeed; }
 
        FlightRules getFlightRules() const { return m_flightRules; }
 
        QString getFlightRulesAsString() const { return CFlightPlan::flightRulesToString(this->getFlightRules()); }
 
        const QString &getRoute() const { return m_route; }
 
        const QDateTime whenLastSentOrLoaded() const { return this->getUtcTimestamp(); }
 
        bool wasSentOrLoaded() const { return this->hasValidTimestamp(); }
 
        qint64 timeDiffSentOrLoadedMs() const { return this->msecsToNow(); }
 
        const QString &getRemarks() const { return m_remarks.getRemarks(); }
 
        const CFlightPlanRemarks &getFlightPlanRemarks() const { return m_remarks; }
 
        void setFlightPlanRemarks(const CFlightPlanRemarks &remarks) { m_remarks = remarks; }
 
        CFlightPlanAircraftInfo getAircraftInfo() const { return m_aircraftInfo; }
 
        QVariant propertyByIndex(CPropertyIndexRef index) const;
 
        void setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant);
 
        CIcons::IconIndex toIcon() const;
 
        QString convertToQString(bool i18n = false) const;
 
        QString asHTML(bool i18n = false) const;
 
        static CFlightPlan fromSB4Format(const QString &sbData);
 
        static CFlightPlan fromSimBriefFormat(const QString &simBrief);
 
        static CFlightPlan fromMultipleFormats(const QString &data, const QString &fileSuffix);
 
        static CFlightPlan loadFromMultipleFormats(const QString &fileName, CStatusMessageList *msgs = nullptr);
 
        static const QString &flightRulesToString(FlightRules rules);
 
        static FlightRules stringToFlightRules(const QString &flightRules);
 
        static const QStringList &flightRules();
 
        static bool isVFRRules(FlightRules rule);
        static bool isVFRRules(const QString &rule);
 
        static bool isIFRRules(FlightRules rule);
        static bool isIFRRules(const QString &rule);
 
    private:
        CCallsign m_callsign; 
        CFlightPlanAircraftInfo m_aircraftInfo; 
        CAirportIcaoCode m_originAirportIcao;
        CAirportIcaoCode m_destinationAirportIcao;
        CAirportIcaoCode m_alternateAirportIcao;
        QDateTime m_takeoffTimePlanned;
        QDateTime m_takeoffTimeActual;
        physical_quantities::CTime m_enrouteTime;
        physical_quantities::CTime m_fuelTime;
        CAltitude m_cruiseAltitude;
        QString m_cruiseAltitudeString;
        physical_quantities::CSpeed m_cruiseTrueAirspeed;
        FlightRules m_flightRules {};
        QString m_route;
        CFlightPlanRemarks m_remarks;
 
        QString buildString(bool i18n = false, const QString &separator = " ") const;
 
        SWIFT_METACLASS(
            CFlightPlan,
            // callsign will be current flight
            SWIFT_METAMEMBER(aircraftInfo),
            SWIFT_METAMEMBER(originAirportIcao),
            SWIFT_METAMEMBER(destinationAirportIcao),
            SWIFT_METAMEMBER(alternateAirportIcao),
            SWIFT_METAMEMBER(takeoffTimePlanned),
            SWIFT_METAMEMBER(takeoffTimeActual),
            SWIFT_METAMEMBER(enrouteTime, 0, LosslessMarshalling),
            SWIFT_METAMEMBER(fuelTime, 0, LosslessMarshalling),
            SWIFT_METAMEMBER(cruiseAltitude, 0, LosslessMarshalling),
            SWIFT_METAMEMBER(cruiseAltitudeString),
            SWIFT_METAMEMBER(cruiseTrueAirspeed, 0, LosslessMarshalling),
            SWIFT_METAMEMBER(flightRules),
            SWIFT_METAMEMBER(route),
            SWIFT_METAMEMBER(remarks),
            SWIFT_METAMEMBER(timestampMSecsSinceEpoch));
    };
} // namespace swift::misc::aviation
 
Q_DECLARE_METATYPE(swift::misc::aviation::CFlightPlanRemarks)
Q_DECLARE_METATYPE(swift::misc::aviation::CFlightPlan)
 
#endif // SWIFT_MISC_AVIATION_FLIGHTPLAN_H