aircraftmodelloader.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_SIMULATION_IAIRCRAFTMODELLOADER_H
#define SWIFT_MISC_SIMULATION_IAIRCRAFTMODELLOADER_H
 
#include <atomic>
#include <functional>
#include <memory>
 
#include <QDateTime>
#include <QFlags>
#include <QMetaType>
#include <QObject>
#include <QString>
#include <QStringList>
 
#include "misc/simulation/aircraftmodelinterfaces.h"
#include "misc/simulation/aircraftmodellist.h"
#include "misc/simulation/data/modelcaches.h"
#include "misc/simulation/settings/simulatorsettings.h"
#include "misc/simulation/simulatorinfo.h"
#include "misc/statusmessagelist.h"
#include "misc/swiftmiscexport.h"
 
namespace swift::misc::simulation
{
    class SWIFT_MISC_EXPORT IAircraftModelLoader :
        public QObject,
        public data::CCentralMultiSimulatorModelCachesAware,
        public IModelsSetable,
        public IModelsUpdatable
    {
        Q_OBJECT
        Q_INTERFACES(swift::misc::simulation::IModelsSetable)
        Q_INTERFACES(swift::misc::simulation::IModelsUpdatable)
        Q_INTERFACES(swift::misc::simulation::IModelsForSimulatorSetable)
        Q_INTERFACES(swift::misc::simulation::IModelsForSimulatorUpdatable)
 
    public:
        static const QStringList &getLogCategories();
 
        enum LoadModeFlag
        {
            NotSet = 0,
            LoadDirectly = 1 << 0, 
            LoadInBackground = 1 << 1, 
            CacheFirst = 1 << 2, 
            CacheSkipped = 1 << 3, 
            CacheOnly = 1 << 4, 
            InBackgroundWithCache = LoadInBackground | CacheFirst, 
            InBackgroundNoCache = LoadInBackground | CacheSkipped 
        };
        Q_DECLARE_FLAGS(LoadMode, LoadModeFlag)
 
        
        enum LoadFinishedInfo
        {
            CacheLoaded, 
            ParsedData, 
            LoadingSkipped, 
            LoadingFailed 
        };
 
        static bool isLoadedInfo(LoadFinishedInfo info) { return info == CacheLoaded || info == ParsedData; }
 
        static const QString &enumToString(LoadFinishedInfo info);
 
        static const QString &enumToString(LoadModeFlag modeFlag);
 
        static QString enumToString(LoadMode mode);
 
        static bool needsCacheSynchronized(LoadMode mode);
 
        using ModelConsolidationCallback = std::function<int(swift::misc::simulation::CAircraftModelList &, bool)>;
 
        virtual ~IAircraftModelLoader() override;
 
        virtual bool isLoadingFinished() const = 0;
 
        void startLoading(LoadMode mode = InBackgroundWithCache,
                          const ModelConsolidationCallback &modelConsolidation = {},
                          const QStringList &modelDirectories = {});
 
        bool isLoadingInProgress() const { return m_loadingInProgress; }
 
        QStringList getModelDirectoriesOrDefault() const;
 
        QString getFirstModelDirectoryOrDefault() const;
 
        QStringList getModelExcludeDirectoryPatterns() const;
 
        const CSimulatorInfo &getSimulator() const { return m_simulator; }
 
        bool supportsSimulator(const CSimulatorInfo &simulator) const { return m_simulator == simulator; }
 
        // Interface implementations
        virtual void setModels(const CAircraftModelList &models) override;
        virtual int updateModels(const CAircraftModelList &models) override;
 
    signals:
        void diskLoadingStarted(const CSimulatorInfo &simulator, IAircraftModelLoader::LoadMode loadMode);
 
        void loadingFinished(const CStatusMessageList &status, const CSimulatorInfo &simulator,
                             IAircraftModelLoader::LoadFinishedInfo info);
 
        void loadingProgress(const CSimulatorInfo &simulator, const QString &message, int progressPercentage);
 
        void cacheChanged(const CSimulatorInfo &simulator);
 
    protected:
        IAircraftModelLoader(const CSimulatorInfo &simulator, QObject *parent = nullptr);
 
        virtual void startLoadingFromDisk(LoadMode mode, const ModelConsolidationCallback &modelConsolidation,
                                          const QStringList &modelDirectories) = 0;
 
        QStringList getInitializedModelDirectories(const QStringList &modelDirectories,
                                                   const CSimulatorInfo &simulator) const;
 
        bool hasCachedData() const;
 
        const CSimulatorInfo m_simulator; 
        std::atomic<bool> m_loadingInProgress { false }; 
        std::atomic<bool> m_cancelLoading { false }; 
        std::atomic<bool> m_skipLoadingEmptyModelDir {
            true
        }; 
        CStatusMessageList m_loadingMessages; 
        settings::CMultiSimulatorSettings m_settings { this }; 
 
    private:
        void setObjectInfo(const CSimulatorInfo &simulatorInfo);
 
        void onLoadingFinished(const CStatusMessageList &statusMsgs, const CSimulatorInfo &simulator,
                               LoadFinishedInfo info);
 
        void onCacheChanged(const CSimulatorInfo &simulator);
    };
 
    class SWIFT_MISC_EXPORT CDummyModelLoader : public IAircraftModelLoader
    {
        Q_OBJECT
 
    public:
        CDummyModelLoader(const CSimulatorInfo &simulator, QObject *parent);
 
        virtual bool isLoadingFinished() const override;
 
    protected:
        virtual void startLoadingFromDisk(LoadMode mode, const ModelConsolidationCallback &modelConsolidation,
                                          const QStringList &modelDirectories) override;
 
    private:
        qint64 m_loadingStartedTs = -1;
    };
} // namespace swift::misc::simulation
 
Q_DECLARE_METATYPE(swift::misc::simulation::IAircraftModelLoader::LoadMode)
Q_DECLARE_METATYPE(swift::misc::simulation::IAircraftModelLoader::LoadModeFlag)
Q_DECLARE_METATYPE(swift::misc::simulation::IAircraftModelLoader::LoadFinishedInfo)
Q_DECLARE_OPERATORS_FOR_FLAGS(swift::misc::simulation::IAircraftModelLoader::LoadMode)
 
#endif // SWIFT_MISC_SIMULATION_IAIRCRAFTMODELLOADER_H