aircrafticaocode.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_MISC_AVIATION_AIRCRAFTICAOCODE_H
#define SWIFT_MISC_AVIATION_AIRCRAFTICAOCODE_H
 
#include <QJsonObject>
#include <QMetaType>
#include <QString>
#include <QStringList>
 
#include "misc/aviation/aircraftcategory.h"
#include "misc/aviation/waketurbulencecategory.h"
#include "misc/db/datastore.h"
#include "misc/metaclass.h"
#include "misc/pq/length.h"
#include "misc/propertyindexref.h"
#include "misc/statusmessagelist.h"
#include "misc/swiftmiscexport.h"
#include "misc/valueobject.h"
 
SWIFT_DECLARE_VALUEOBJECT_MIXINS(swift::misc::aviation, CAircraftIcaoCode)
 
namespace swift::misc::aviation
{
    class SWIFT_MISC_EXPORT CAircraftIcaoCode :
        public CValueObject<CAircraftIcaoCode>,
        public db::IDatastoreObjectWithIntegerKey
    {
    public:
        enum ColumnIndex
        {
            IndexAircraftDesignator = CPropertyIndexRef::GlobalIndexCAircraftIcaoCode,
            IndexIataCode,
            IndexFamily,
            IndexCombinedAircraftType,
            IndexManufacturer,
            IndexModelDescription,
            IndexModelIataDescription,
            IndexModelSwiftDescription,
            IndexCombinedDescription,
            IndexWtc,
            IndexIsRealworld,
            IndexIsMilitary,
            IndexIsLegacy,
            IndexIsVtol,
            IndexRank,
            IndexCategory,
            IndexDesignatorManufacturer 
        };
 
        CAircraftIcaoCode() {}
 
        CAircraftIcaoCode(const QString &icao, const QString &combinedType = "");
 
        CAircraftIcaoCode(const QString &icao, const QString &combinedType, const QString &manufacturer,
                          const QString &model, CWakeTurbulenceCategory wtc, bool realworld, bool legacy, bool military,
                          int rank);
 
        CAircraftIcaoCode(const QString &icao, const QString &iata, const QString &combinedType,
                          const QString &manufacturer, const QString &model, CWakeTurbulenceCategory wtc,
                          bool realworld, bool legacy, bool military, int rank);
 
        CAircraftIcaoCode(const QString &icao, const QString &iata, const QString &family, const QString &combinedType,
                          const QString &manufacturer, const QString &model, const QString &modelIata,
                          const QString &modelSwift, CWakeTurbulenceCategory wtc, bool realworld, bool legacy,
                          bool military, int rank);
 
        const QString &getDesignator() const { return m_designator; }
 
        QString getDesignatorDbKey() const;
 
        QString getDesignatorManufacturer() const;
 
        void setDesignator(const QString &icaoDesignator) { m_designator = icaoDesignator.trimmed().toUpper(); }
 
        bool hasDesignator() const;
 
        bool hasValidDesignator() const;
 
        bool hasKnownDesignator() const;
 
        bool hasSpecialDesignator() const;
 
        const QString &getIataCode() const { return m_iataCode; }
 
        void setIataCode(const QString &iata) { m_iataCode = iata.toUpper().trimmed(); }
 
        bool hasIataCode() const { return !m_iataCode.isEmpty(); }
 
        bool isIataSameAsDesignator() const;
 
        const QString &getFamily() const { return m_family; }
 
        void setFamily(const QString &family) { m_family = family.toUpper().trimmed(); }
 
        bool hasFamily() const { return !m_family.isEmpty(); }
 
        bool isFamilySameAsDesignator() const;
 
        const QString &getCombinedType() const { return m_combinedType; }
 
        bool hasValidCombinedType() const;
 
        QString getEngineType() const;
 
        QChar getEngineTypeChar() const;
 
        int getEnginesCount() const;
 
        QString getEngineCountString() const;
 
        QString getAircraftType() const;
 
        QChar getAircraftTypeChar() const;
 
        void setCombinedType(const QString &type) { m_combinedType = type.trimmed().toUpper(); }
 
        const QString &getModelDescription() const { return m_modelDescription; }
 
        const QString &getModelIataDescription() const { return m_modelIataDescription; }
 
        const QString &getModelSwiftDescription() const { return m_modelSwiftDescription; }
 
        QString getCombinedModelDescription() const;
 
        bool matchesAnyDescription(const QString &candidate) const;
 
        bool matchesCombinedType(const QString &combinedType) const;
 
        bool matchesCombinedTypeAndManufacturer(const QString &combinedType, const QString &manufacturer) const;
 
        void setModelDescription(const QString &modelDescription) { m_modelDescription = modelDescription.trimmed(); }
 
        void setModelIataDescription(const QString &modelDescription)
        {
            m_modelIataDescription = modelDescription.trimmed();
        }
 
        void setModelSwiftDescription(const QString &modelDescription)
        {
            m_modelSwiftDescription = modelDescription.trimmed();
        }
 
        bool hasModelDescription() const { return !m_modelDescription.isEmpty(); }
 
        bool hasModelIataDescription() const { return !m_modelIataDescription.isEmpty(); }
 
        bool hasModelSwiftDescription() const { return !m_modelSwiftDescription.isEmpty(); }
 
        const QString &getManufacturer() const { return m_manufacturer; }
 
        void setManufacturer(const QString &manufacturer) { m_manufacturer = manufacturer.trimmed(); }
 
        bool hasManufacturer() const;
 
        bool matchesManufacturer(const QString &manufacturer) const;
 
        CWakeTurbulenceCategory getWtc() const { return m_wtc; }
 
        void setWtc(CWakeTurbulenceCategory wtc) { m_wtc = wtc; }
 
        bool hasValidWtc() const { return !m_wtc.isUnknown(); }
 
        bool isVtol() const;
 
        bool isMilitary() const { return m_military; }
 
        bool isRealWorld() const { return m_realWorld; }
 
        bool isLegacyAircraft() const { return m_legacy; }
 
        bool isDbDuplicate() const;
 
        void setCodeFlags(bool military, bool legacy, bool realWorld);
 
        void setMilitary(bool military);
 
        void setRealWorld(bool realWorld);
 
        void setLegacy(bool legacy);
 
        int getRank() const { return m_rank; }
 
        QString getRankString() const;
 
        void setRank(int rank);
 
        QString getCombinedIcaoStringWithKey() const;
 
        QString getCombinedIcaoCategoryStringWithKey() const;
 
        QString getCombinedIataStringWithKey() const;
 
        QString getCombinedFamilyStringWithKey() const;
 
        const CAircraftCategory &getCategory() const { return m_category; }
 
        bool hasCategory() const;
 
        void setCategory(const CAircraftCategory &category) { m_category = category; }
 
        void setCategoryId(int id) { m_category.setDbKey(id); }
 
        bool hasCompleteData() const;
 
        bool matchesDesignator(const QString &designator, int fuzzyMatch = -1, int *result = nullptr) const;
 
        bool matchesIataCode(const QString &iata, int fuzzyMatch = -1, int *result = nullptr) const;
 
        bool matchesFamily(const QString &family, int fuzzyMatch = -1, int *result = nullptr) const;
 
        bool matchesDesignatorOrIata(const QString &icaoOrIata) const;
 
        bool matchesDesignatorIataOrFamily(const QString &icaoIataOrFamily) const;
 
        QVariant propertyByIndex(swift::misc::CPropertyIndexRef index) const;
 
        void setPropertyByIndex(swift::misc::CPropertyIndexRef index, const QVariant &variant);
 
        int comparePropertyByIndex(CPropertyIndexRef index, const CAircraftIcaoCode &compareValue) const;
 
        QString convertToQString(bool i18n = false) const;
 
        void updateMissingParts(const CAircraftIcaoCode &otherIcaoCode);
 
        CStatusMessageList validate() const;
 
        QString asHtmlSummary() const;
 
        int calculateScore(const CAircraftIcaoCode &otherCode, CStatusMessageList *log = nullptr) const;
 
        void guessModelParameters(physical_quantities::CLength &guessedCGOut,
                                  physical_quantities::CSpeed &guessedVRotateOut) const;
 
        bool isNull() const;
 
        static const CAircraftIcaoCode &null();
 
        static bool isValidDesignator(const QString &designator);
 
        static bool isValidCombinedType(const QString &combinedType);
 
        static const QString &getUnassignedDesignator();
 
        static const QString &getGliderDesignator();
 
        static const CAircraftIcaoCode &unassignedIcao();
 
        static const QStringList &getSpecialDesignators();
 
        static QString normalizeDesignator(const QString &candidate);
 
        static QStringList alternativeCombinedCodes(const QString &combinedCode);
 
        static bool isEPTEngineType(const QChar engineType);
 
        static CStatusMessage logMessage(const CAircraftIcaoCode &icaoCode, const QString &message,
                                         const QStringList &extraCategories = {},
                                         CStatusMessage::StatusSeverity s = CStatusMessage::SeverityInfo);
 
        static void addLogDetailsToList(CStatusMessageList *log, const CAircraftIcaoCode &icao, const QString &message,
                                        const QStringList &extraCategories = {},
                                        CStatusMessage::StatusSeverity s = CStatusMessage::SeverityInfo);
 
        static CAircraftIcaoCode fromDatabaseJson(const QJsonObject &json, const QString &prefix = QString());
 
        static constexpr int DesignatorMinLength = 2; 
        static constexpr int DesignatorMaxLength = 5; 
 
    private:
        QString m_designator; 
        QString m_iataCode; 
        QString m_family; 
        QString m_combinedType; 
        QString m_manufacturer; 
        QString m_modelDescription; 
        QString m_modelIataDescription; 
        QString m_modelSwiftDescription; 
        CWakeTurbulenceCategory m_wtc; 
        bool m_realWorld = true; 
        bool m_legacy = false; 
        bool m_military = false; 
        int m_rank = 10; 
        CAircraftCategory m_category; 
 
        static QString createdCombinedString(const QString &type, const QString &engineCount, const QString &engine);
 
        static QString createdCombinedString(const QString &type, int engineCount, const QString &engine);
 
        SWIFT_METACLASS(
            CAircraftIcaoCode,
            SWIFT_METAMEMBER(dbKey),
            SWIFT_METAMEMBER(timestampMSecsSinceEpoch),
            SWIFT_METAMEMBER(designator),
            SWIFT_METAMEMBER(iataCode),
            SWIFT_METAMEMBER(family),
            SWIFT_METAMEMBER(combinedType),
            SWIFT_METAMEMBER(manufacturer),
            SWIFT_METAMEMBER(modelDescription),
            SWIFT_METAMEMBER(modelIataDescription),
            SWIFT_METAMEMBER(modelSwiftDescription),
            SWIFT_METAMEMBER(category),
            SWIFT_METAMEMBER(wtc),
            SWIFT_METAMEMBER(military),
            SWIFT_METAMEMBER(realWorld),
            SWIFT_METAMEMBER(legacy),
            SWIFT_METAMEMBER(rank));
    };
 
    using AircraftIcaoIdMap = QMap<int, CAircraftIcaoCode>;
 
} // namespace swift::misc::aviation
 
Q_DECLARE_METATYPE(swift::misc::aviation::CAircraftIcaoCode)
 
#endif // SWIFT_MISC_AVIATION_AIRCRAFTICAOCODE_H