aircraftmodel.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_SIMULATION_AIRCRAFTMODEL_H
#define SWIFT_MISC_SIMULATION_AIRCRAFTMODEL_H
 
#include <tuple>
 
#include <QDir>
#include <QFileInfo>
#include <QFlags>
#include <QHash>
#include <QJsonDocument>
#include <QJsonObject>
#include <QMetaType>
#include <QStringList>
#include <Qt>
 
#include "misc/aviation/aircrafticaocode.h"
#include "misc/aviation/airlineicaocode.h"
#include "misc/aviation/callsign.h"
#include "misc/aviation/livery.h"
#include "misc/db/datastore.h"
#include "misc/dictionary.h"
#include "misc/memotable.h"
#include "misc/metaclass.h"
#include "misc/orderable.h"
#include "misc/pixmap.h"
#include "misc/pq/length.h"
#include "misc/propertyindexref.h"
#include "misc/simulation/distributor.h"
#include "misc/simulation/distributorlist.h"
#include "misc/simulation/simulatorinfo.h"
#include "misc/statusmessagelist.h"
#include "misc/swiftmiscexport.h"
#include "misc/valueobject.h"
 
SWIFT_DECLARE_VALUEOBJECT_MIXINS(swift::misc::Simulation, CAircraftModel)
 
namespace swift::misc
{
    class CIcon;
 
    namespace simulation
    {
        struct DBTripleIds
        {
            int model = -1; 
            int livery = -1; 
            int aircraft = -1; 
 
            bool hasAnyId() const { return model >= 0 || livery >= 0 || aircraft >= 0; }
 
            QString toQString() const
            {
                return QStringLiteral("Model: %1 Livery: %2 Aircraft: %3").arg(model).arg(livery).arg(aircraft);
            }
        };
 
        class SWIFT_MISC_EXPORT CAircraftModel :
            public CValueObject<CAircraftModel>,
            public db::IDatastoreObjectWithIntegerKey, // also ITimestampBased
            public IOrderable
        {
        public:
            enum ModelType
            {
                TypeUnknown,
                TypeQueriedFromNetwork, 
                TypeFSInnData, 
                TypeReverseLookup, 
                TypeModelMatching, 
                TypeModelMatchingDefaultModel, 
                TypeDatabaseEntry, 
                TypeManuallySet, 
                TypeOwnSimulatorModel, 
                TypeVPilotRuleBased, 
                TypeTerrainProbe 
            };
 
            enum ModelMode
            {
                Undefined = 0,
                Include = 1 << 0,
                Exclude = 1 << 1,
                All = Include | Exclude
            };
 
            Q_DECLARE_FLAGS(ModelModeFilter, ModelMode)
 
            
            enum ColumnIndex
            {
                IndexModelString = CPropertyIndexRef::GlobalIndexCAircraftModel,
                IndexModelStringAlias,
                IndexAllModelStrings, 
                IndexCallsign,
                IndexName,
                IndexDescription,
                IndexSimulatorInfo,
                IndexSimulatorInfoAsString,
                IndexAircraftIcaoCode,
                IndexLivery,
                IndexCG,
                IndexDistributor,
                IndexFileName,
                IndexFileTimestamp,
                IndexFileTimestampFormattedYmdhms,
                IndexModelType,
                IndexModelTypeAsString,
                IndexModelMode,
                IndexModelModeAsString,
                IndexSupportedParts,
                IndexModelModeAsIcon,
                IndexHasQueriedModelString,
                IndexMembersDbStatus
            };
 
            static void registerMetadata();
 
            CAircraftModel() {}
 
            CAircraftModel(const QString &model, ModelType type);
 
            CAircraftModel(const QString &model, ModelType type, const aviation::CAircraftIcaoCode &icao,
                           const aviation::CLivery &livery);
 
            CAircraftModel(const QString &model, ModelType type, const QString &description,
                           const aviation::CAircraftIcaoCode &icao,
                           const aviation::CLivery &livery = aviation::CLivery());
 
            CAircraftModel(const QString &model, ModelType type, const CSimulatorInfo &simulator, const QString &name,
                           const QString &description);
 
            CAircraftModel(const QString &model, ModelType type, const CSimulatorInfo &simulator, const QString &name,
                           const QString &description, const aviation::CAircraftIcaoCode &icao,
                           const aviation::CLivery &livery = aviation::CLivery());
 
            QVariant propertyByIndex(CPropertyIndexRef index) const;
 
            void setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant);
 
            int comparePropertyByIndex(CPropertyIndexRef index, const CAircraftModel &compareValue) const;
 
            QString convertToQString(bool i18n = false) const;
 
            bool canInitializeFromFsd() const;
 
            const aviation::CCallsign &getCallsign() const { return m_callsign; }
 
            void setCallsign(const aviation::CCallsign &callsign);
 
            bool isCallsignEmpty() const { return m_callsign.isEmpty(); }
 
            const QString &getModelString() const { return m_modelString; }
 
            QString getModelStringAndDbKey() const;
 
            void setModelString(const QString &modelString) { m_modelString = modelString.trimmed().toUpper(); }
 
            const QString &getModelStringAlias() const { return m_modelStringAlias; }
 
            QString getAllModelStringsAndAliases() const;
 
            QString getAllModelStringsAliasesAndDbKey() const;
 
            void setModelStringAlias(const QString &alias) { m_modelStringAlias = alias.trimmed().toUpper(); }
 
            const QString &getDescription() const { return m_description; }
 
            void setDescription(const QString &description) { m_description = description.trimmed(); }
 
            void setQueriedModelString(const QString &model)
            {
                m_modelString = model;
                m_modelType = TypeQueriedFromNetwork;
            }
 
            const aviation::CAircraftIcaoCode &getAircraftIcaoCode() const { return m_aircraftIcao; }
 
            int getEngineCount() const { return m_aircraftIcao.getEnginesCount(); }
 
            const QString &getAircraftIcaoCodeDesignator() const { return m_aircraftIcao.getDesignator(); }
 
            bool isVtol() const;
 
            const aviation::CAirlineIcaoCode &getAirlineIcaoCode() const { return m_livery.getAirlineIcaoCode(); }
 
            bool setAirlineIcaoDesignator(const QString &designator)
            {
                return m_livery.setAirlineIcaoCodeDesignator(designator);
            }
 
            const QString &getAirlineIcaoCodeDesignator() const
            {
                return m_livery.getAirlineIcaoCode().getDesignator();
            }
 
            const QString getAirlineIcaoCodeVDesignator() const
            {
                return m_livery.getAirlineIcaoCode().getVDesignator();
            }
 
            bool setAircraftIcaoCode(const aviation::CAircraftIcaoCode &aircraftIcaoCode);
 
            void setAircraftIcaoDesignator(const QString &designator);
 
            void setAircraftIcaoCodes(const aviation::CAircraftIcaoCode &aircraftIcaoCode,
                                      const aviation::CAirlineIcaoCode &airlineIcaoCode);
 
            bool hasValidAircraftAndAirlineDesignator() const;
 
            bool hasAircraftDesignator() const;
 
            bool hasKnownAircraftDesignator() const;
 
            bool hasCategory() const;
 
            bool hasAirlineDesignator() const;
 
            bool hasAircraftAndAirlineDesignator() const;
 
            bool isMilitary() const;
 
            bool isCivilian() const;
 
            const aviation::CLivery &getLivery() const { return m_livery; }
 
            void setLivery(const aviation::CLivery &livery) { m_livery = livery; }
 
            bool hasLivery() const { return m_livery.hasCompleteData(); }
 
            const CDistributor &getDistributor() const { return m_distributor; }
 
            int getDistributorOrder() const { return m_distributor.getOrder(); }
 
            void setDistributor(const CDistributor &distributor) { m_distributor = distributor; }
 
            bool setDistributorOrder(int order);
 
            bool setDistributorOrder(const CDistributorList &distributors);
 
            bool hasDbDistributor() const;
 
            bool hasDistributor() const;
 
            bool matchesDbDistributor(const CDistributor &distributor) const;
 
            bool matchesAnyDbDistributor(const CDistributorList &distributors) const;
 
            const QString &getName() const { return m_name; }
 
            void setName(const QString &name) { m_name = name.trimmed(); }
 
            const physical_quantities::CLength &getCG() const { return m_cg; }
 
            void setCG(const physical_quantities::CLength &cg) { m_cg = cg; }
 
            bool hasCG() const { return !m_cg.isNull(); }
 
            const QString &getSupportedParts() const { return m_supportedParts; }
 
            void setSupportedParts(const QString &supportedParts);
 
            ModelType getModelType() const { return m_modelType; }
 
            bool isTerrainProbe() const { return m_modelType == TypeTerrainProbe; }
 
            const QString &getModelTypeAsString() const { return modelTypeToString(getModelType()); }
 
            void setModelType(ModelType type) { m_modelType = type; }
 
            ModelMode getModelMode() const { return m_modelMode; }
 
            bool matchesMode(simulation::CAircraftModel::ModelModeFilter mode) const;
 
            const QString &getModelModeAsString() const { return modelModeToString(getModelMode()); }
 
            const CIcon &getModelModeAsIcon() const;
 
            void setModelMode(ModelMode mode) { m_modelMode = mode; }
 
            void setModelModeAsString(const QString &mode);
 
            CSimulatorInfo getSimulator() const { return m_simulator; }
 
            void setSimulator(const CSimulatorInfo &simulator) { m_simulator = simulator; }
 
            bool matchesSimulator(const CSimulatorInfo &simulator) const;
 
            bool matchesSimulatorFlag(CSimulatorInfo::Simulator simulator) const;
 
            QString getSwiftLiveryString(bool aircraftIcao = true, bool livery = true, bool model = true) const;
 
            QString getSwiftLiveryString(const CSimulatorInfo &sim) const;
 
            void updateMissingParts(const CAircraftModel &otherModel, bool dbModelPriority = true);
 
            void updateByExistingDirectories(const CAircraftModel &otherModel);
 
            bool hasQueriedModelString() const;
 
            bool hasManuallySetString() const;
 
            bool hasModelString() const { return !m_modelString.isEmpty(); }
 
            bool hasModelStringAlias() const { return !m_modelStringAlias.isEmpty(); }
 
            bool hasAnyModelString() const { return this->hasModelString() || this->hasModelStringAlias(); }
 
            bool hasDescription(bool ignoreAutoGenerated = false) const;
 
            bool hasValidSimulator() const;
 
            QString getMembersDbStatus() const;
 
            bool matchesModelString(const QString &modelString, Qt::CaseSensitivity sensitivity) const;
 
            bool matchesModelStringOrAlias(const QString &modelString, Qt::CaseSensitivity sensitivity) const;
 
            int calculateScore(const CAircraftModel &compareModel, bool preferColorLiveries,
                               CStatusMessageList *log = nullptr) const;
 
            CStatusMessageList validate(bool withNestedObjects) const;
 
            bool isEqualForPublishing(const CAircraftModel &dbModel, CStatusMessageList *details = nullptr) const;
 
            using MemoHelper = CMemoHelper<aviation::CAircraftIcaoCode, aviation::CLivery, CDistributor>;
 
            QJsonObject toMemoizedJson(MemoHelper::CMemoizer &) const;
 
            void convertFromMemoizedJson(const QJsonObject &json, const MemoHelper::CUnmemoizer &);
 
            QJsonObject toDatabaseJson() const;
 
            QString toDatabaseJsonString(QJsonDocument::JsonFormat format = QJsonDocument::Compact) const;
 
            QString asHtmlSummary(const QString &separator = "<br>") const;
 
            // ---------------- simulator file related functions -------------------
 
            const QString &getFileName() const { return m_fileName; }
 
            QString getFileNameLowerCase() const { return m_fileName.toLower(); }
 
            bool hasFileName() const { return !m_fileName.isEmpty(); }
 
            bool matchesFileName(const QString &fileName) const;
 
            bool hasExistingCorrespondingFile() const;
 
            QDir getFileDirectory() const;
 
            QString getFileDirectoryPath() const;
 
            bool isInPath(const QString &path, Qt::CaseSensitivity cs) const;
 
            void setFileName(const QString &fileName) { m_fileName = fileName; }
 
            QDateTime getFileTimestamp() const;
 
            QString getFormattedFileTimestampYmdhms() const;
 
            bool hasValidFileTimestamp() const;
 
            void setFileTimestamp(const QDateTime &timestampUtc);
 
            void setFileTimestamp(qint64 timestamp);
 
            void setFileDetailsAndTimestamp(const QFileInfo &fileInfo);
 
            void normalizeFileNameForDb();
 
            void updateLocalFileNames(const CAircraftModel &model);
 
            bool adjustLocalFileNames(const QString &newModelDir, const QString &stripModelDirIndicator = {});
 
            // ---------------- end file related functions --------------
 
            CStatusMessageList verifyModelData() const;
 
            static const QString &modelTypeToString(ModelType type);
 
            static QString normalizeFileNameForDb(const QString &filePath);
 
            static ModelMode modelModeFromString(const QString &mode);
 
            static const QString &modelModeToString(ModelMode mode);
 
            static CAircraftModel fromDatabaseJson(const QJsonObject &json, const QString &prefix = QString("mod_"));
 
            static CAircraftModel
            fromDatabaseJsonCaching(const QJsonObject &json, aviation::AircraftIcaoIdMap &aircraftIcaos,
                                    const aviation::AircraftCategoryIdMap &categories, aviation::LiveryIdMap &liveries,
                                    DistributorIdMap &distributors, const QString &prefix = QString("mod_"));
 
            static const QString &liveryStringPrefix();
 
            static bool isSwiftLiveryString(const QString &liveryString);
 
            static DBTripleIds parseNetworkLiveryString(const QString &liveryString);
 
            static const QString &autoGenerated();
 
            static QString cleanUpPartsString(const QString &p);
 
            static const QString &supportedParts();
 
        private:
            static CAircraftModel fromDatabaseJsonBaseImpl(const QJsonObject &json, const QString &prefix,
                                                           const aviation::CAircraftIcaoCode &aircraftIcao,
                                                           const aviation::CLivery &livery,
                                                           const CDistributor &distributor);
 
            aviation::CCallsign m_callsign; 
            aviation::CAircraftIcaoCode m_aircraftIcao; 
            aviation::CLivery m_livery; 
            CSimulatorInfo m_simulator; 
            CDistributor m_distributor; 
            QString m_modelString; 
            QString m_modelStringAlias; 
            QString m_name; 
            QString m_description; 
            QString m_fileName; 
            QString m_supportedParts; 
            qint64 m_fileTimestamp = -1; 
            ModelType m_modelType = TypeUnknown; 
            ModelMode m_modelMode = Include; 
            physical_quantities::CLength m_cg = physical_quantities::CLength::null(); 
 
            SWIFT_METACLASS(
                CAircraftModel,
                SWIFT_METAMEMBER(dbKey),
                SWIFT_METAMEMBER(timestampMSecsSinceEpoch),
                SWIFT_METAMEMBER(order),
                SWIFT_METAMEMBER(callsign),
                SWIFT_METAMEMBER(aircraftIcao),
                SWIFT_METAMEMBER(livery),
                SWIFT_METAMEMBER(simulator),
                SWIFT_METAMEMBER(distributor),
                SWIFT_METAMEMBER(cg),
                SWIFT_METAMEMBER(supportedParts),
                SWIFT_METAMEMBER(modelString, 0, CaseInsensitiveComparison),
                SWIFT_METAMEMBER(modelStringAlias, 0, CaseInsensitiveComparison),
                SWIFT_METAMEMBER(name),
                SWIFT_METAMEMBER(description, 0, DisabledForComparison),
                SWIFT_METAMEMBER(fileName, 0, DisabledForComparison),
                SWIFT_METAMEMBER(fileTimestamp, 0, DisabledForComparison),
                SWIFT_METAMEMBER(modelType),
                SWIFT_METAMEMBER(modelMode));
        };
    } // namespace simulation
} // namespace swift::misc
 
Q_DECLARE_METATYPE(swift::misc::simulation::CAircraftModel)
Q_DECLARE_METATYPE(swift::misc::simulation::CAircraftModel::ModelType)
Q_DECLARE_METATYPE(swift::misc::simulation::CAircraftModel::ModelMode)
Q_DECLARE_METATYPE(swift::misc::simulation::CAircraftModel::ModelModeFilter)
Q_DECLARE_OPERATORS_FOR_FLAGS(swift::misc::simulation::CAircraftModel::ModelModeFilter)
 
#endif // SWIFT_MISC_SIMULATION_AIRCRAFTMODEL_H