simulatorinfo.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_SIMULATORINFO_H
#define SWIFT_MISC_SIMULATION_SIMULATORINFO_H
 
#include <QFlag>
#include <QFlags>
#include <QJsonObject>
#include <QList>
#include <QMetaType>
#include <QMultiMap>
#include <QSet>
#include <QStringList>
 
#include "misc/metaclass.h"
#include "misc/propertyindexref.h"
#include "misc/statusmessage.h"
#include "misc/swiftmiscexport.h"
#include "misc/valueobject.h"
 
SWIFT_DECLARE_VALUEOBJECT_MIXINS(swift::misc::Simulation, CSimulatorInfo)
 
namespace swift::misc::simulation
{
    class SWIFT_MISC_EXPORT CSimulatorInfo : public CValueObject<CSimulatorInfo>
    {
    public:
        enum SimulatorFlag
        {
            None = 0,
            FSX_DEPRECATED = 1 << 0, // kept for backwards compatibility
            FS9_DEPRECATED = 1 << 1, // kepts for backwards compatibility
            XPLANE = 1 << 2,
            P3D = 1 << 3,
            FG = 1 << 4,
            MSFS = 1 << 5,
            MSFS2024 = 1 << 6,
            AllFsFamily = P3D | MSFS | MSFS2024,
            All = XPLANE | P3D | FG | MSFS | MSFS2024
        };
        Q_DECLARE_FLAGS(Simulator, SimulatorFlag)
 
        
        static constexpr int NumberOfSimulators = 7;
 
        CSimulatorInfo() = default;
 
        CSimulatorInfo(const QString &identifierString);
 
        CSimulatorInfo(const QStringList &simulators);
 
        CSimulatorInfo(Simulator s);
 
        CSimulatorInfo(int flagsAsInt);
 
        CSimulatorInfo(bool xp, bool isP3D, bool fg, bool msfs, bool msfs2024);
 
        bool isUnspecified() const;
 
        bool isXPlane() const;
 
        bool isP3D() const;
 
        bool isFG() const;
 
        bool isMSFS() const;
 
        bool isMSFS2024() const;
 
        bool isAnySimulator() const;
 
        bool isSingleSimulator() const;
 
        bool isNoSimulator() const;
 
        bool isMultipleSimulators() const;
 
        bool isAllSimulators() const;
 
        bool isMicrosoftSimulator() const;
 
        bool isMicrosoftOrPrepare3DSimulator() const;
 
        bool isFsxP3DFamily() const;
 
        int numberSimulators() const;
 
        bool matchesAll(const CSimulatorInfo &otherInfo) const;
 
        bool matchesAny(const CSimulatorInfo &otherInfo) const;
 
        bool matchesAnyOrNone(const CSimulatorInfo &otherInfo) const;
 
        Simulator getSimulator() const { return static_cast<Simulator>(m_simulator); }
 
        void setSimulator(Simulator s) { m_simulator = static_cast<int>(s); }
 
        void addSimulator(Simulator s) { m_simulator |= static_cast<int>(s); }
 
        void addSimulator(const CSimulatorInfo &simulatorInfo) { this->addSimulator(simulatorInfo.getSimulator()); }
 
        void setAllSimulators() { setSimulator(All); }
 
        int comparePropertyByIndex(CPropertyIndexRef index, const CSimulatorInfo &compareValue) const;
 
        QString convertToQString(bool i18n = false) const;
 
        CIcons::IconIndex toIcon() const;
 
        CSimulatorInfo add(const CSimulatorInfo &other);
 
        QSet<CSimulatorInfo> asSingleSimulatorSet() const;
 
        void invertSimulators();
 
        CStatusMessage validateSimulatorsForModel() const;
 
        static Simulator boolToFlag(bool xp, bool isP3D, bool fg, bool msfs, bool msfs2024);
 
        static Simulator identifierToSimulator(const QString &identifier);
 
        static const CSimulatorInfo &allSimulators();
 
        static const QStringList &allSimulatorStrings();
 
        static const QSet<CSimulatorInfo> &allSimulatorsSet();
 
        static const CSimulatorInfo &allFsFamilySimulators();
 
        static CSimulatorInfo getLocallyInstalledSimulators();
 
        static const CSimulatorInfo &guessDefaultSimulator();
 
        static CSimulatorInfo fromDatabaseJson(const QJsonObject &json, const QString &prefix);
 
        static const CSimulatorInfo &fg()
        {
            static const CSimulatorInfo s(FG);
            return s;
        }
        static const CSimulatorInfo &p3d()
        {
            static const CSimulatorInfo s(P3D);
            return s;
        }
        static const CSimulatorInfo &xplane()
        {
            static const CSimulatorInfo s(XPLANE);
            return s;
        }
        static const CSimulatorInfo &msfs()
        {
            static const CSimulatorInfo s(MSFS);
            return s;
        }
        static const CSimulatorInfo &msfs2024()
        {
            static const CSimulatorInfo s(MSFS2024);
            return s;
        }
 
    private:
        int m_simulator = static_cast<int>(None);
 
        SWIFT_METACLASS(
            CSimulatorInfo,
            SWIFT_METAMEMBER(simulator));
    };
 
    class SWIFT_MISC_EXPORT CCountPerSimulator
    {
    public:
        CCountPerSimulator();
 
        int getCount(const CSimulatorInfo &simulator) const;
 
        int getCountForUnknownSimulators() const;
 
        int getCountForFsFamilySimulators() const;
 
        int getCountForFsxFamilySimulators() const;
 
        void setCount(int count, const CSimulatorInfo &simulator);
 
        void increaseSimulatorCounts(const CSimulatorInfo &simulator);
 
        int getMaximum() const;
 
        int getMinimum() const;
 
        int simulatorsRepresented() const;
 
        QMultiMap<int, CSimulatorInfo> countPerSimulator() const;
 
        QString toQString() const;
 
    private:
        QList<int> m_counts;
        static int internalIndex(const CSimulatorInfo &simulator);
        static CSimulatorInfo simulator(int internalIndex);
    };
} // namespace swift::misc::simulation
 
Q_DECLARE_METATYPE(swift::misc::simulation::CSimulatorInfo)
Q_DECLARE_METATYPE(swift::misc::simulation::CSimulatorInfo::SimulatorFlag)
Q_DECLARE_OPERATORS_FOR_FLAGS(swift::misc::simulation::CSimulatorInfo::Simulator)
 
#endif // SWIFT_MISC_SIMULATION_SIMULATORINFO_H