Add PRS1ModelInfo to manage the set of supported and tested machines.

Also move an extra unsupported check out of PRSImport::ImportSummary
into CreateMachineFromProperties, where it should intervene before
reaching PRS1Import. Leave a warning debug message in its place.

oscar/SleepLib/loader_plugins/prs1_loader.cpp

@@ -196,6 +196,7 @@ enum FlexMode { FLEX_None, FLEX_CFlex, FLEX_CFlexPlus, FLEX_AFlex, FLEX_RiseTime
 
 ChannelID PRS1_TimedBreath = 0, PRS1_HeatedTubing = 0;
 
+#if 0  // Apparently unused
 PRS1::PRS1(Profile *profile, MachineID id): CPAP(profile, id)
 {
 }
@@ -203,18 +204,105 @@ PRS1::~PRS1()
 {
 
 }
-
-
-#if 0 // TODO: Remove: unused, superseded by PRS1Waveform
-/*! \struct WaveHeaderList
-    \brief Used in PRS1 Waveform Parsing */
-struct WaveHeaderList {
-    quint16 interleave;
-    quint8  sample_format;
-    WaveHeaderList(quint16 i, quint8 f) { interleave = i; sample_format = f; }
-};
 #endif
 
+struct PRS1TestedModel
+{
+    QString model;
+    int family;
+    int familyVersion;
+};
+
+static const PRS1TestedModel s_PRS1TestedModels[] = {
+    { "450P", 0, 3 },
+    { "550P", 0, 2 },
+    { "550P", 0, 3 },
+    { "750P", 0, 2 },
+
+    { "460P",   0, 4 },
+    { "560P",   0, 4 },
+    { "560PBT", 0, 4 },
+    { "660P",   0, 4 },
+    { "760P",   0, 4 },
+    
+    { "200X110", 0, 6 },
+    { "400G110", 0, 6 },
+    { "400X110", 0, 6 },
+    { "400X150", 0, 6 },
+    { "500X110", 0, 6 },
+    { "500X150", 0, 6 },
+    { "502G150", 0, 6 },
+    { "600X110", 0, 6 },
+    { "700X110", 0, 6 },
+    
+    { "950P", 5, 0 },
+    { "960P", 5, 1 },
+    { "961P", 5, 1 },
+    { "960T", 5, 2 },
+    { "900X110", 5, 3 },
+    { "900X120", 5, 3 },
+    
+    { "1160P", 3, 3 },
+    { "1030X110", 3, 6 },
+    { "1130X110", 3, 6 },
+    
+    { "", 0, 0 },
+};
+PRS1ModelInfo s_PRS1ModelInfo;
+
+PRS1ModelInfo::PRS1ModelInfo()
+{
+    for (int i = 0; !s_PRS1TestedModels[i].model.isEmpty(); i++) {
+        const PRS1TestedModel & model = s_PRS1TestedModels[i];
+        m_testedModels[model.family][model.familyVersion].append(model.model);
+    }
+}
+
+bool PRS1ModelInfo::IsSupported(int family, int familyVersion) const
+{
+    if (m_testedModels.value(family).contains(familyVersion)) {
+        return true;
+    }
+    return false;
+}
+
+bool PRS1ModelInfo::IsTested(const QString & model, int family, int familyVersion) const
+{
+    if (m_testedModels.value(family).value(familyVersion).contains(model)) {
+        return true;
+    }
+    return false;
+};
+
+bool PRS1ModelInfo::IsSupported(const QHash<QString,QString> & props) const
+{
+    bool ok;
+    int family = props["Family"].toInt(&ok, 10);
+    if (ok) {
+        int familyVersion = props["FamilyVersion"].toInt(&ok, 10);
+        if (ok) {
+            ok = IsSupported(family, familyVersion);
+        }
+    }
+    return ok;
+}
+
+bool PRS1ModelInfo::IsTested(const QHash<QString,QString> & props) const
+{
+    bool ok;
+    int family = props["Family"].toInt(&ok, 10);
+    if (ok) {
+        int familyVersion = props["FamilyVersion"].toInt(&ok, 10);
+        if (ok) {
+            ok = IsTested(props["ModelNumber"], family, familyVersion);
+        }
+    }
+    return ok;
+};
+
+// TODO: add brick list, IsBrick() test
+// TODO: add model name, Name() function
+
 
 PRS1Loader::PRS1Loader()
 {
@@ -232,7 +320,6 @@ PRS1Loader::PRS1Loader()
     m_pixmaps["DreamStation"] = QPixmap(DREAMSTATION_ICON);
 #endif
 
-    //genCRCTable();  // find what I did with this..
     m_type = MT_CPAP;
 }
 
@@ -390,45 +477,93 @@ void parseModel(MachineInfo & info, const QString & modelnum)
     }
 }
 
-bool PRS1Loader::PeekProperties(MachineInfo & info, const QString & filename, Machine * mach)
+bool PRS1Loader::PeekProperties(const QString & filename, QHash<QString,QString> & props)
 {
+    const static QMap<QString,QString> s_longFieldNames = {
+        // CF?
+        { "SN", "SerialNumber" },
+        { "MN", "ModelNumber" },
+        { "PT", "ProductType" },
+        { "DF", "DataFormat" },
+        { "DFV", "DataFormatVersion" },
+        { "F", "Family" },
+        { "FV", "FamilyVersion" },
+        { "SV", "SoftwareVersion" },
+        { "FD", "FirstDate" },
+        { "LD", "LastDate" },
+        // SID?
+        // SK?
+        { "BK", "BasicKey" },
+        { "DK", "DetailsKey" },
+        { "EK", "ErrorKey" },
+        { "FN", "PatientFolderNum" },  // most recent Pn directory
+        { "PFN", "PatientFileNum" },   // number of files in the most recent Pn directory
+        { "EFN", "EquipFileNum" },     // number of .004 files in the E directory
+        { "DFN", "DFileNum" },         // number of .003 files in the D directory
+        { "VC", "ValidCheck" },
+    };
+    
     QFile f(filename);
     if (!f.open(QFile::ReadOnly)) {
         return false;
     }
     QTextStream in(&f);
-    QString modelnum;
-    int ptype=0;
-    int dfv=0;
-    bool ok;
     do {
         QString line = in.readLine();
         QStringList pair = line.split("=");
 
+        if (s_longFieldNames.contains(pair[0])) {
+            pair[0] = s_longFieldNames[pair[0]];
+        }
+        if (pair[0] == "Family") {
+            if (pair[1] == "xPAP") {
+                pair[1] = "0";
+            }
+        }
+        props[pair[0]] = pair[1];
+    } while (!in.atEnd());
+    
+    return true;
+}
+
+bool PRS1Loader::PeekProperties(MachineInfo & info, const QString & filename, Machine * mach)
+{
+    QHash<QString,QString> props;
+    if (!PeekProperties(filename, props)) {
+        return false;
+    }
+    QString modelnum;
+    int ptype=0;
+    int dfv=0;
+    bool ok;
+    for (auto & key : props.keys()) {
         bool skip = false;
 
-        if (pair[0].contains("ModelNumber", Qt::CaseInsensitive) || pair[0].contains("MN", Qt::CaseInsensitive)) {
+        if (key == "ModelNumber") {
-            modelnum = pair[1];
+            modelnum = props[key];
             skip = true;
         }
-        if (pair[0].contains("SerialNumber", Qt::CaseInsensitive) || pair[0].contains("SN", Qt::CaseInsensitive)) {
+        if (key == "SerialNumber") {
-            info.serial = pair[1];
+            info.serial = props[key];
             skip = true;
         }
-        if (pair[0].contains("ProductType", Qt::CaseInsensitive) || pair[0].contains("PT", Qt::CaseInsensitive)) {
+        if (key == "ProductType") {
-            ptype = pair[1].toInt(&ok, 16);
+            ptype = props[key].toInt(&ok, 16);
+            if (!ok) qWarning() << "ProductType" << props[key];
             skip = true;
         }
-        if (pair[0].contains("DataFormatVersion", Qt::CaseInsensitive) || pair[0].contains("DFV", Qt::CaseInsensitive)) {
+        if (key == "DataFormatVersion") {
-            dfv = pair[1].toInt(&ok, 10);
+            dfv = props[key].toInt(&ok, 10);
+            if (!ok) qWarning() << "DataFormatVersion" << props[key];
             skip = true;
         }
         if (!mach || skip) continue;
 
-        mach->properties[pair[0]] = pair[1];
+        mach->properties[key] = props[key];
-
+    };
-    } while (!in.atEnd());
 
+    // TODO: replace the below logic with PRS1ModelInfo table-driven logic
+    
     if (!modelnum.isEmpty()) {
         parseModel(info, modelnum);
     }
@@ -763,6 +898,16 @@ Machine* PRS1Loader::CreateMachineFromProperties(QString propertyfile)
 
     // This time supply the machine object so it can populate machine properties..
     PeekProperties(m->info, propertyfile, m);
+
+    // TODO: Replace much of the above logic with PRS1ModelInfo logic.
+    QHash<QString,QString> props;
+    PeekProperties(propertyfile, props);
+    if (!s_PRS1ModelInfo.IsSupported(props)) {
+        if (!m->unsupported()) {
+            unsupported(m);
+        }
+    }
+    
     return m;
 }
 
@@ -4002,11 +4147,7 @@ bool PRS1Import::ParseSummary()
         ;
     }
 
-    this->loader->saveMutex.lock();
+    qWarning() << "unexpected family" << summary->family << "familyVersion" << summary->familyVersion;
-    if (!mach->unsupported()) {
-        this->loader->unsupported(mach);
-    }
-    this->loader->saveMutex.unlock();
     return false;
 
     //////////////////////////////////////////////////////////////////////////////////////////

oscar/SleepLib/loader_plugins/prs1_loader.h

@@ -28,7 +28,7 @@
 const int prs1_data_version = 15;
 //
 //********************************************************************************************
-
+#if 0  // Apparently unused
 /*! \class PRS1
     \brief PRS1 customized machine object (via CPAP)
     */
@@ -41,6 +41,7 @@ class PRS1: public CPAP
 
 
 const int max_load_buffer_size = 1024 * 1024;
+#endif
 const QString prs1_class_name = STR_MACH_PRS1;
 
 /*! \struct PRS1Waveform
@@ -291,6 +292,9 @@ class PRS1Loader : public CPAPLoader
     //! \brief Examine path and return it back if it contains what looks to be a valid PRS1 SD card structure
     QString checkDir(const QString & path);
 
+    //! \brief Peek into PROP.TXT or properties.txt at given path, and return it as a normalized key/value hash
+    bool PeekProperties(const QString & filename, QHash<QString,QString> & props);
+    
     //! \brief Peek into PROP.TXT or properties.txt at given path, and use it to fill MachineInfo structure
     bool PeekProperties(MachineInfo & info, const QString & path, Machine * mach = nullptr);
 
@@ -378,4 +382,21 @@ class PRS1Loader : public CPAPLoader
     qint32 summary_duration;
 };
 
+
+//********************************************************************************************
+
+class PRS1ModelInfo
+{
+protected:
+    QHash<int, QHash<int, QStringList>> m_testedModels;
+    
+public:
+    PRS1ModelInfo();
+    bool IsSupported(const QHash<QString,QString> & properties) const;
+    bool IsSupported(int family, int familyVersion) const;
+    bool IsTested(const QHash<QString,QString> & properties) const;
+    bool IsTested(const QString & modelNumber, int family, int familyVersion) const;
+};
+
+
 #endif // PRS1LOADER_H

oscar/tests/prs1tests.cpp

@@ -33,6 +33,47 @@ void PRS1Tests::cleanupTestCase(void)
 }
 
 
+// ====================================================================================================
+
+extern PRS1ModelInfo s_PRS1ModelInfo;
+void PRS1Tests::testMachineSupport()
+{
+    QHash<QString,QString> tested = {
+        { "ModelNumber", "550P" },
+        { "Family", "0" },
+        { "FamilyVersion", "3" },
+    };
+    QHash<QString,QString> supported = {
+        { "ModelNumber", "700X999" },
+        { "Family", "0" },
+        { "FamilyVersion", "6" },
+    };
+    QHash<QString,QString> unsupported = {
+        { "ModelNumber", "550P" },
+        { "Family", "0" },
+        { "FamilyVersion", "9" },
+    };
+    
+    Q_ASSERT(s_PRS1ModelInfo.IsSupported(5, 3));
+    Q_ASSERT(!s_PRS1ModelInfo.IsSupported(5, 9));
+    Q_ASSERT(!s_PRS1ModelInfo.IsSupported(9, 9));
+    Q_ASSERT(s_PRS1ModelInfo.IsTested("550P", 0, 2));
+    Q_ASSERT(s_PRS1ModelInfo.IsTested("550P", 0, 3));
+    Q_ASSERT(s_PRS1ModelInfo.IsTested("760P", 0, 4));
+    Q_ASSERT(s_PRS1ModelInfo.IsTested("700X110", 0, 6));
+    Q_ASSERT(!s_PRS1ModelInfo.IsTested("700X999", 0, 6));
+    
+    Q_ASSERT(s_PRS1ModelInfo.IsTested(tested));
+    Q_ASSERT(!s_PRS1ModelInfo.IsTested(supported));
+    Q_ASSERT(s_PRS1ModelInfo.IsSupported(tested));
+    Q_ASSERT(s_PRS1ModelInfo.IsSupported(supported));
+    Q_ASSERT(!s_PRS1ModelInfo.IsSupported(unsupported));
+}
+
+
+// ====================================================================================================
+
+
 void parseAndEmitSessionYaml(const QString & path)
 {
     qDebug() << path;

oscar/tests/prs1tests.h

@@ -18,6 +18,7 @@ class PRS1Tests : public QObject
  
 private slots:
     void initTestCase();
+    void testMachineSupport();
     void testChunksToYaml();
     void testSessionsToYaml();
     // void test2();