refs #452, simulator info class (which simulator is supported?)

src/blackmisc/simulation/simulatorinfo.cpp

@@ -8,8 +8,11 @@
  */
 
 #include "simulatorinfo.h"
+#include "blackmisc/project.h"
+#include "blackmisc/simulation/fscommon/fscommonutil.h"
 
 using namespace BlackMisc;
+using namespace BlackMisc::Simulation::FsCommon;
 
 namespace BlackMisc
 {
@@ -18,11 +21,18 @@ namespace BlackMisc
         CSimulatorInfo::CSimulatorInfo()
         { }
 
-        CSimulatorInfo::CSimulatorInfo(Simulator s) : m_simulator(static_cast<int>(s))
+        CSimulatorInfo::CSimulatorInfo(const QString &identifierString) :  m_simulator(identifierToFlag(identifierString))
         { }
 
-        CSimulatorInfo::CSimulatorInfo(bool fsx, bool fs9, bool xp) :
-            m_simulator(boolToFlag(fsx, fs9, xp))
+        CSimulatorInfo::CSimulatorInfo(Simulator simulator) : m_simulator(static_cast<int>(simulator))
+        { }
+
+        CSimulatorInfo::CSimulatorInfo(bool fsx, bool fs9, bool xp, bool p3d) :
+            m_simulator(boolToFlag(fsx, fs9, xp, p3d))
+        { }
+
+        CSimulatorInfo::CSimulatorInfo(int flagsAsInt) :
+            m_simulator(flagsAsInt)
         { }
 
         bool CSimulatorInfo::isUnspecified() const
@@ -30,6 +40,51 @@ namespace BlackMisc
             return m_simulator < 1;
         }
 
+        bool CSimulatorInfo::fsx() const
+        {
+            return getSimulator().testFlag(FSX);
+        }
+
+        bool CSimulatorInfo::fs9() const
+        {
+            return getSimulator().testFlag(FS9);
+        }
+
+        bool CSimulatorInfo::xplane() const
+        {
+            return getSimulator().testFlag(XPLANE);
+        }
+
+        bool CSimulatorInfo::p3d() const
+        {
+            return getSimulator().testFlag(P3D);
+        }
+
+        bool CSimulatorInfo::isAnySimulator() const
+        {
+            return fsx() || fs9() || xplane() || p3d();
+        }
+
+        bool CSimulatorInfo::isNoSimulator() const
+        {
+            return m_simulator == 0;
+        }
+
+        bool CSimulatorInfo::isAllSimulators() const
+        {
+            return fsx() && fs9() && xplane() && p3d();
+        }
+
+        bool CSimulatorInfo::matchesAll(const CSimulatorInfo &otherInfo) const
+        {
+            return (this->m_simulator & otherInfo.m_simulator) == otherInfo.m_simulator;
+        }
+
+        bool CSimulatorInfo::matchesAny(const CSimulatorInfo &otherInfo) const
+        {
+            return (this->m_simulator & otherInfo.m_simulator) > 0;
+        }
+
         QString CSimulatorInfo::convertToQString(bool i18n) const
         {
             Q_UNUSED(i18n);
@@ -37,15 +92,23 @@ namespace BlackMisc
             QString str;
             if (s.testFlag(FSX)) { str.append("FSX "); }
             if (s.testFlag(FS9)) { str.append("FS9 "); }
-            if (s.testFlag(XP)) { str.append("XPlane "); }
+            if (s.testFlag(XPLANE)) { str.append("XPlane "); }
+            if (s.testFlag(P3D)) { str.append("P3D "); }
             return str.trimmed();
         }
 
-        CSimulatorInfo::Simulator CSimulatorInfo::boolToFlag(bool fsx, bool fs9, bool xp)
+        void CSimulatorInfo::add(const CSimulatorInfo &other)
+        {
+            if (other.isUnspecified()) { return; }
+            this->setSimulator(this->getSimulator() | other.getSimulator());
+        }
+
+        CSimulatorInfo::Simulator CSimulatorInfo::boolToFlag(bool fsx, bool fs9, bool xp, bool p3d)
         {
             Simulator s = fsx ? FSX : None;
             if (fs9) { s |= FS9; }
-            if (xp)  { s |= XP; }
+            if (xp)  { s |= XPLANE; }
+            if (p3d) { s |= P3D; }
             return s;
         }
 
@@ -55,7 +118,7 @@ namespace BlackMisc
             if (i.isEmpty()) { return None; }
 
             Simulator s = None;
-            if (i.contains("fsx"))
+            if (i.contains("fsx") || i.contains(" sx"))
             {
                 s |= FSX;
             }
@@ -63,11 +126,45 @@ namespace BlackMisc
             {
                 s |= FS9;
             }
-            if (i.contains("xplane")  || i.contains("xp"))
+            if (i.contains("xplane")  || i.contains("xp") || i.contains("x plane"))
             {
-                s |= XP;
+                s |= XPLANE;
+            }
+            if (i.contains("3d")  || i.contains("prepare"))
+            {
+                s |= P3D;
             }
             return s;
         }
+
+        const CSimulatorInfo &CSimulatorInfo::allSimulators()
+        {
+            static const CSimulatorInfo s(All);
+            return s;
+        }
+
+        const CSimulatorInfo CSimulatorInfo::getLocallyInstalledSimulators()
+        {
+            //! \todo add XP, ...
+            CSimulatorInfo sim;
+            bool fs9 =
+                CProject::isRunningOnWindowsNtPlatform() &&
+                !CFsCommonUtil::fs9AircraftDir().isEmpty() &&
+                !CFsCommonUtil::fs9Dir().isEmpty();
+            bool fsx =
+                CProject::isRunningOnWindowsNtPlatform() &&
+                !CFsCommonUtil::fsxSimObjectsDir().isEmpty() &&
+                !CFsCommonUtil::fsxDir().isEmpty();
+            bool p3d =
+                CProject::isRunningOnWindowsNtPlatform() &&
+                !CFsCommonUtil::p3dDir().isEmpty() &&
+                !CFsCommonUtil::p3dSimObjectsDir().isEmpty();
+            bool xp = true; //! \todo XP resolution
+
+            sim.setSimulator(
+                CSimulatorInfo::boolToFlag(fsx, fs9, xp, p3d)
+            );
+            return sim;
+        }
     } // ns
 } // ns