modelcaches.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2016 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_SIMULATION_DATA_MODELCACHES
#define SWIFT_MISC_SIMULATION_DATA_MODELCACHES
 
#include <atomic>
 
#include <QDateTime>
#include <QObject>
 
#include "misc/applicationinfo.h"
#include "misc/datacache.h"
#include "misc/simulation/aircraftmodelinterfaces.h"
#include "misc/simulation/aircraftmodellist.h"
#include "misc/simulation/simulatorinfo.h"
#include "misc/statusmessage.h"
#include "misc/swiftmiscexport.h"
#include "misc/threadutils.h"
 
namespace swift::misc::simulation::data
{
    struct TModelCache : public TDataTrait<CAircraftModelList>
    {
        static constexpr bool isDeferred() { return true; }
    };
 
 
    struct TModelCacheXP : public TModelCache
    {
        static const char *key() { return "modelcachexp"; }
    };
 
    struct TModelCacheP3D : public TModelCache
    {
        static const char *key() { return "modelcachep3d"; }
    };
 
    struct TModelCacheFG : public TModelCache
    {
        static const char *key() { return "modelcachefg"; }
    };
 
    struct TModelCacheMsfs : public TModelCache
    {
        static const char *key() { return "modelcachemsfs"; }
    };
 
    struct TModelCacheMsfs2024 : public TModelCache
    {
        static const char *key() { return "modelcachemsfs2024"; }
    };
 
    struct TModelCacheLastSelection : public TDataTrait<CSimulatorInfo>
    {
        static constexpr bool isPinned() { return true; }
 
        static const CSimulatorInfo &defaultValue() { return CSimulatorInfo::guessDefaultSimulator(); }
 
        static const char *key() { return "modelcachelastselection"; }
    };
 
 
    struct TModelSetCacheXP : public TModelCache
    {
        static const char *key() { return "modelsetxp"; }
    };
 
    struct TModelSetCacheP3D : public TModelCache
    {
        static const char *key() { return "modelsetp3d"; }
    };
 
    struct TModelSetCacheFG : public TModelCache
    {
        static const char *key() { return "modelsetfg"; }
    };
 
    struct TModelSetCacheMsfs : public TModelCache
    {
        static const char *key() { return "modelsetmsfs"; }
    };
 
    struct TModelSetCacheMsfs2024 : public TModelCache
    {
        static const char *key() { return "modelsetmsfs2024"; }
    };
 
    struct TSimulatorLastSelection : public TDataTrait<CSimulatorInfo>
    {
        static constexpr bool isPinned() { return true; }
 
        static const CSimulatorInfo &defaultValue() { return CSimulatorInfo::guessDefaultSimulator(); }
 
        static const char *key() { return "simulatorlastselection"; }
    };
 
    struct TSimulatorLastSelections : public TDataTrait<CSimulatorInfo>
    {
        static constexpr bool isPinned() { return true; }
 
        static const CSimulatorInfo &defaultValue() { return CSimulatorInfo::guessDefaultSimulator(); }
 
        static const char *key() { return "simulatorlastselections"; }
    };
 
    struct TVPilotAircraftModels : public TModelCache
    {
        static const char *key() { return "vpilot/models"; }
    };
 
    class SWIFT_MISC_EXPORT IMultiSimulatorModelCaches :
        public QObject,
        public IModelsForSimulatorSetable,
        public IModelsForSimulatorUpdatable
    {
        Q_OBJECT
        Q_INTERFACES(swift::misc::simulation::IModelsForSimulatorSetable)
        Q_INTERFACES(swift::misc::simulation::IModelsForSimulatorUpdatable)
 
    public:
        void setModelsForSimulator(const CAircraftModelList &models, const CSimulatorInfo &simulator) override;
 
        int updateModelsForSimulator(const CAircraftModelList &models, const CSimulatorInfo &simulator) override;
 
        virtual CAircraftModelList getCachedModels(const CSimulatorInfo &simulator) const = 0;
 
        CAircraftModelList getSynchronizedCachedModels(const CSimulatorInfo &simulator);
 
        int getCachedModelsCount(const CSimulatorInfo &simulator) const;
 
        virtual QString getFilename(const CSimulatorInfo &simulator) const = 0;
 
        bool hasOtherVersionFile(const swift::misc::CApplicationInfo &info, const CSimulatorInfo &simulator) const;
 
        CSimulatorInfo otherVersionSimulatorsWithFile(const swift::misc::CApplicationInfo &info) const;
 
        virtual QStringList getAllFilenames() const;
 
        CSimulatorInfo getSimulatorForFilename(const QString &filename) const;
 
        virtual QDateTime getCacheTimestamp(const CSimulatorInfo &simulator) const = 0;
 
        virtual CStatusMessage setCacheTimestamp(const QDateTime &ts, const CSimulatorInfo &simulator) = 0;
 
        virtual bool isSaved(const CSimulatorInfo &simulator) const = 0;
 
        CSimulatorInfo simulatorsWithInitializedCache() const;
 
        CSimulatorInfo simulatorsWithModels() const;
 
        QDateTime getSynchronizedTimestamp(const CSimulatorInfo &simulator);
 
        virtual CStatusMessage setCachedModels(const CAircraftModelList &models, const CSimulatorInfo &simulator) = 0;
 
        virtual CStatusMessage clearCachedModels(const CSimulatorInfo &simulator);
 
        virtual void synchronizeCache(const CSimulatorInfo &simulator) = 0;
 
        bool isCacheAlreadySynchronized(const CSimulatorInfo &simulator) const;
 
        virtual void synchronizeMultiCaches(const CSimulatorInfo &simulator);
 
        virtual void admitCache(const CSimulatorInfo &simulator) = 0;
 
        virtual void admitMultiCaches(const CSimulatorInfo &simulator);
 
        QString getInfoString() const;
 
        QString getInfoStringFsFamily() const;
 
        QString getCacheCountAndTimestamp(const CSimulatorInfo &simulator) const;
 
        virtual void gracefulShutdown();
 
        virtual QString getDescription() const = 0;
 
    signals:
        void cacheChanged(const swift::misc::simulation::CSimulatorInfo &simulator);
 
    protected:
        IMultiSimulatorModelCaches(QObject *parent = nullptr) : QObject(parent) {}
 
        void changedP3D() { this->emitCacheChanged(CSimulatorInfo::p3d()); }
        void changedXP() { this->emitCacheChanged(CSimulatorInfo::xplane()); }
        void changedFG() { this->emitCacheChanged(CSimulatorInfo::fg()); }
        void changedMsfs() { this->emitCacheChanged(CSimulatorInfo::msfs()); }
        void changedMsfs2024() { this->emitCacheChanged(CSimulatorInfo::msfs2024()); }
 
        void markCacheAsAlreadySynchronized(const CSimulatorInfo &simulator, bool synchronized);
 
        void emitCacheChanged(const CSimulatorInfo &simulator);
 
    private:
        std::atomic_bool m_syncP3D { false };
        std::atomic_bool m_syncFG { false };
        std::atomic_bool m_syncXPlane { false };
        std::atomic_bool m_syncMsfs { false };
        std::atomic_bool m_syncMsfs2024 { false };
    };
 
    class SWIFT_MISC_EXPORT CModelCaches : public IMultiSimulatorModelCaches
    {
        Q_OBJECT
 
    public:
        CModelCaches(bool synchronizeCache, QObject *parent = nullptr);
 
        static const QStringList &getLogCategories();
 
        CAircraftModelList getCachedModels(const CSimulatorInfo &simulator) const override;
        CStatusMessage setCachedModels(const CAircraftModelList &models, const CSimulatorInfo &simulator) override;
        QDateTime getCacheTimestamp(const CSimulatorInfo &simulator) const override;
        CStatusMessage setCacheTimestamp(const QDateTime &ts, const CSimulatorInfo &simulator) override;
        void synchronizeCache(const CSimulatorInfo &simulator) override;
        void admitCache(const CSimulatorInfo &simulator) override;
        QString getFilename(const CSimulatorInfo &simulator) const override;
        bool isSaved(const CSimulatorInfo &simulator) const override;
        QString getDescription() const override { return "Model caches"; }
 
    private:
        CData<TModelCacheP3D> m_modelCacheP3D { this, &CModelCaches::changedP3D }; 
        CData<TModelCacheXP> m_modelCacheXP { this, &CModelCaches::changedXP }; 
        CData<TModelCacheFG> m_modelCacheFG { this, &CModelCaches::changedFG }; 
        CData<TModelCacheMsfs> m_modelCacheMsfs { this, &CModelCaches::changedMsfs }; 
        CData<TModelCacheMsfs2024> m_modelCacheMsfs2024 { this, &CModelCaches::changedMsfs2024 }; 
 
        void synchronizeCacheImpl(const CSimulatorInfo &simulator);
 
        bool admitCacheImpl(const CSimulatorInfo &simulator);
    };
 
    class SWIFT_MISC_EXPORT CModelSetCaches : public IMultiSimulatorModelCaches
    {
        Q_OBJECT
 
    public:
        CModelSetCaches(bool synchronizeCache, QObject *parent = nullptr);
 
        static const QStringList &getLogCategories();
 
        CAircraftModelList getCachedModels(const CSimulatorInfo &simulator) const override;
        CStatusMessage setCachedModels(const CAircraftModelList &models, const CSimulatorInfo &simulator) override;
        QDateTime getCacheTimestamp(const CSimulatorInfo &simulator) const override;
        CStatusMessage setCacheTimestamp(const QDateTime &ts, const CSimulatorInfo &simulator) override;
        void synchronizeCache(const CSimulatorInfo &simulator) override;
        void admitCache(const CSimulatorInfo &simulator) override;
        QString getFilename(const CSimulatorInfo &simulator) const override;
        bool isSaved(const CSimulatorInfo &simulator) const override;
        QString getDescription() const override { return "Model sets"; }
 
    private:
        CData<TModelSetCacheP3D> m_modelCacheP3D { this, &CModelSetCaches::changedP3D }; 
        CData<TModelSetCacheXP> m_modelCacheXP { this, &CModelSetCaches::changedXP }; 
        CData<TModelSetCacheFG> m_modelCacheFG { this, &CModelSetCaches::changedFG }; 
        CData<TModelSetCacheMsfs> m_modelCacheMsfs { this, &CModelSetCaches::changedMsfs }; 
        CData<TModelSetCacheMsfs2024> m_modelCacheMsfs2024 { this,
                                                             &CModelSetCaches::changedMsfs2024 }; 
 
        void synchronizeCacheImpl(const CSimulatorInfo &simulator);
 
        bool admitCacheImpl(const CSimulatorInfo &simulator);
    };
 
    template <class TCaches, class Derived>
    class CCentralMultiSimulatorModelCachesProviderBase : public IMultiSimulatorModelCaches
    {
    public:
 
        CAircraftModelList getCachedModels(const CSimulatorInfo &simulator) const override
        {
            return instanceCaches().getCachedModels(simulator);
        }
 
        CStatusMessage setCachedModels(const CAircraftModelList &models, const CSimulatorInfo &simulator) override
        {
            return instanceCaches().setCachedModels(models, simulator);
        }
 
        QDateTime getCacheTimestamp(const CSimulatorInfo &simulator) const override
        {
            return instanceCaches().getCacheTimestamp(simulator);
        }
 
        CStatusMessage setCacheTimestamp(const QDateTime &ts, const CSimulatorInfo &simulator) override
        {
            return instanceCaches().setCacheTimestamp(ts, simulator);
        }
 
        void synchronizeCache(const CSimulatorInfo &simulator) override
        {
            return instanceCaches().synchronizeCache(simulator);
        }
 
        void admitCache(const CSimulatorInfo &simulator) override { return instanceCaches().admitCache(simulator); }
 
        QString getFilename(const CSimulatorInfo &simulator) const override
        {
            return instanceCaches().getFilename(simulator);
        }
 
        bool isSaved(const CSimulatorInfo &simulator) const override { return instanceCaches().isSaved(simulator); }
 
        QString getDescription() const override { return instanceCaches().getDescription(); }
 
    protected:
        CCentralMultiSimulatorModelCachesProviderBase(const QString &name, QObject *parent = nullptr)
            : IMultiSimulatorModelCaches(parent)
        {
            this->setObjectName(name);
            connect(&m_caches, &IMultiSimulatorModelCaches::cacheChanged, this,
                    &CCentralMultiSimulatorModelCachesProviderBase::cacheChanged);
        }
 
    private:
        TCaches m_caches { false, this }; 
 
        TCaches &instanceCaches() { return this->isInstance() ? m_caches : Derived::modelCachesInstance().m_caches; }
 
        const TCaches &instanceCaches() const
        {
            return this->isInstance() ? m_caches : Derived::modelCachesInstance().m_caches;
        }
 
        bool isInstance() const { return this == &Derived::modelCachesInstance(); }
    };
 
    class SWIFT_MISC_EXPORT CCentralMultiSimulatorModelCachesProvider :
        public CCentralMultiSimulatorModelCachesProviderBase<CModelCaches, CCentralMultiSimulatorModelCachesProvider>
    {
        Q_OBJECT
        Q_INTERFACES(swift::misc::simulation::IModelsForSimulatorSetable)
        Q_INTERFACES(swift::misc::simulation::IModelsForSimulatorUpdatable)
 
    public:
        static CCentralMultiSimulatorModelCachesProvider &modelCachesInstance()
        {
            static CCentralMultiSimulatorModelCachesProvider c("Central model caches provider");
            Q_ASSERT_X(CThreadUtils::isInThisThread(&c), Q_FUNC_INFO, "Wrong thread");
            return c;
        }
 
    protected:
        CCentralMultiSimulatorModelCachesProvider(const QString &name, QObject *parent = nullptr)
            : CCentralMultiSimulatorModelCachesProviderBase(name, parent)
        {}
    };
 
    class SWIFT_MISC_EXPORT CCentralMultiSimulatorModelCachesAware :
        public IModelsForSimulatorSetable,
        public IModelsForSimulatorUpdatable
    {
    public:
        CAircraftModelList getCachedModels(const CSimulatorInfo &simulator) const
        {
            return CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().getCachedModels(simulator);
        }
        int getCachedModelsCount(const CSimulatorInfo &simulator) const
        {
            return CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().getCachedModelsCount(simulator);
        }
        QString getCacheCountAndTimestamp(const CSimulatorInfo &simulator) const
        {
            return CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().getCacheCountAndTimestamp(
                simulator);
        }
        CStatusMessage setCachedModels(const CAircraftModelList &models, const CSimulatorInfo &simulator)
        {
            return CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().setCachedModels(models, simulator);
        }
        CStatusMessage clearCachedModels(const CSimulatorInfo &simulator)
        {
            return CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().clearCachedModels(simulator);
        }
        QDateTime getCacheTimestamp(const CSimulatorInfo &simulator) const
        {
            return CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().getCacheTimestamp(simulator);
        }
        CStatusMessage setCacheTimestamp(const QDateTime &ts, const CSimulatorInfo &simulator)
        {
            return CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().setCacheTimestamp(ts, simulator);
        }
        void synchronizeCache(const CSimulatorInfo &simulator)
        {
            CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().synchronizeCache(simulator);
        }
        void admitCache(const CSimulatorInfo &simulator)
        {
            CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().admitCache(simulator);
        }
        QString getFilename(const CSimulatorInfo &simulator) const
        {
            return CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().getFilename(simulator);
        }
        bool isSaved(const CSimulatorInfo &simulator) const
        {
            return CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().isSaved(simulator);
        }
        QString getDescription() const
        {
            return CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().getDescription();
        }
        QString getInfoString() const
        {
            return CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().getInfoString();
        }
        QString getInfoStringFsFamily() const
        {
            return CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().getInfoStringFsFamily();
        }
 
        void setModelsForSimulator(const CAircraftModelList &models, const CSimulatorInfo &simulator) override
        {
            CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().setModelsForSimulator(models, simulator);
        }
 
        int updateModelsForSimulator(const CAircraftModelList &models, const CSimulatorInfo &simulator) override
        {
            return CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().updateModelsForSimulator(models,
                                                                                                             simulator);
        }
    };
 
    class SWIFT_MISC_EXPORT CCentralMultiSimulatorModelSetCachesProvider :
        public CCentralMultiSimulatorModelCachesProviderBase<CModelSetCaches,
                                                             CCentralMultiSimulatorModelSetCachesProvider>
    {
        Q_OBJECT
        Q_INTERFACES(swift::misc::simulation::IModelsForSimulatorSetable)
        Q_INTERFACES(swift::misc::simulation::IModelsForSimulatorUpdatable)
 
    public:
        static CCentralMultiSimulatorModelSetCachesProvider &modelCachesInstance()
        {
            static CCentralMultiSimulatorModelSetCachesProvider c("Central model sets provider");
            Q_ASSERT_X(CThreadUtils::isInThisThread(&c), Q_FUNC_INFO, "Wrong thread");
            return c;
        }
 
    protected:
        CCentralMultiSimulatorModelSetCachesProvider(const QString &name, QObject *parent = nullptr)
            : CCentralMultiSimulatorModelCachesProviderBase(name, parent)
        {}
    };
 
    class SWIFT_MISC_EXPORT CCentralMultiSimulatorModelSetCachesAware :
        public IModelsForSimulatorSetable,
        public IModelsForSimulatorUpdatable
    {
    public:
        CAircraftModelList getCachedModels(const CSimulatorInfo &simulator) const
        {
            return CCentralMultiSimulatorModelSetCachesProvider::modelCachesInstance().getCachedModels(simulator);
        }
        int getCachedModelsCount(const CSimulatorInfo &simulator) const
        {
            return CCentralMultiSimulatorModelSetCachesProvider::modelCachesInstance().getCachedModelsCount(simulator);
        }
        QString getCacheCountAndTimestamp(const CSimulatorInfo &simulator) const
        {
            return CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().getCacheCountAndTimestamp(
                simulator);
        }
        CStatusMessage setCachedModels(const CAircraftModelList &models, const CSimulatorInfo &simulator)
        {
            return CCentralMultiSimulatorModelSetCachesProvider::modelCachesInstance().setCachedModels(models,
                                                                                                       simulator);
        }
        CStatusMessage clearCachedModels(const CSimulatorInfo &simulator)
        {
            return CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().clearCachedModels(simulator);
        }
        QDateTime getCacheTimestamp(const CSimulatorInfo &simulator) const
        {
            return CCentralMultiSimulatorModelSetCachesProvider::modelCachesInstance().getCacheTimestamp(simulator);
        }
        CStatusMessage setCacheTimestamp(const QDateTime &ts, const CSimulatorInfo &simulator)
        {
            return CCentralMultiSimulatorModelSetCachesProvider::modelCachesInstance().setCacheTimestamp(ts, simulator);
        }
        void synchronizeCache(const CSimulatorInfo &simulator)
        {
            CCentralMultiSimulatorModelSetCachesProvider::modelCachesInstance().synchronizeCache(simulator);
        }
        void admitCache(const CSimulatorInfo &simulator)
        {
            CCentralMultiSimulatorModelSetCachesProvider::modelCachesInstance().admitCache(simulator);
        }
        QString getFilename(const CSimulatorInfo &simulator) const
        {
            return CCentralMultiSimulatorModelSetCachesProvider::modelCachesInstance().getFilename(simulator);
        }
        bool isSaved(const CSimulatorInfo &simulator) const
        {
            return CCentralMultiSimulatorModelSetCachesProvider::modelCachesInstance().isSaved(simulator);
        }
        QString getDescription() const
        {
            return CCentralMultiSimulatorModelSetCachesProvider::modelCachesInstance().getDescription();
        }
        QString getInfoString() const
        {
            return CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().getInfoString();
        }
        QString getInfoStringFsFamily() const
        {
            return CCentralMultiSimulatorModelCachesProvider::modelCachesInstance().getInfoStringFsFamily();
        }
 
        void setModelsForSimulator(const CAircraftModelList &models, const CSimulatorInfo &simulator) override
        {
            CCentralMultiSimulatorModelSetCachesProvider::modelCachesInstance().setModelsForSimulator(models,
                                                                                                      simulator);
        }
 
        int updateModelsForSimulator(const CAircraftModelList &models, const CSimulatorInfo &simulator) override
        {
            return CCentralMultiSimulatorModelSetCachesProvider::modelCachesInstance().updateModelsForSimulator(
                models, simulator);
        }
    };
 
} // namespace swift::misc::simulation::data
 
#endif // SWIFT_MISC_SIMULATION_DATA_MODELCACHES