chris/OSCAR-code
1
0
Fork 0
mirror of https://gitlab.com/pholy/OSCAR-code.git synced 2025-04-05 10:40:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Convert PRS1ParsedEvent enums to static constants, update switch statements.

Browse Source
This commit is contained in:
sawinglogz 2019-05-27 21:02:28 -04:00
parent 3b4a5b4dd6
commit 7c949fc843
1 changed files with 155 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

380
oscar/SleepLib/loader_plugins/prs1_loader.cpp
View File

@ -1099,6 +1099,12 @@ void PRS1Loader::ScanFiles(const QStringList & paths, int sessionid_base, Machin
} }
} }
//********************************************************************************************
// Internal PRS1 parsed data types
//********************************************************************************************
// For new events, add an enum here and then a class below with an PRS1_*_EVENT macro
enum PRS1ParsedEventType enum PRS1ParsedEventType
{ {
EV_PRS1_RAW = -1, // these only get logged EV_PRS1_RAW = -1, // these only get logged
@ -1186,9 +1192,13 @@ public:
inline float value(void) { return (m_value * m_gain) + m_offset; } inline float value(void) { return (m_value * m_gain) + m_offset; }
static const PRS1ParsedEventType TYPE = EV_PRS1_UNKNOWN;
static constexpr float GAIN = 1.0;
static const PRS1ParsedEventUnit UNIT = PRS1_UNIT_NONE;
protected: protected:
PRS1ParsedEvent(PRS1ParsedEventType type, int start) PRS1ParsedEvent(PRS1ParsedEventType type, int start)
: m_type(type), m_start(start), m_duration(0), m_value(0), m_offset(0.0), m_gain(1.0), m_unit(PRS1_UNIT_NONE) : m_type(type), m_start(start), m_duration(0), m_value(0), m_offset(0.0), m_gain(GAIN), m_unit(UNIT)
{ {
} }
~PRS1ParsedEvent() ~PRS1ParsedEvent()
@ -1215,17 +1225,20 @@ class PRS1UnknownValueEvent : public PRS1ParsedValueEvent
{ {
public: public:
int m_code; int m_code;
PRS1UnknownValueEvent(int code, int start, int value, float gain=1.0) : PRS1ParsedValueEvent(EV_PRS1_UNKNOWN, start, value), m_code(code) { m_gain = gain; } PRS1UnknownValueEvent(int code, int start, int value, float gain=1.0) : PRS1ParsedValueEvent(TYPE, start, value), m_code(code) { m_gain = gain; }
}; };
class PRS1UnknownDataEvent : public PRS1ParsedEvent class PRS1UnknownDataEvent : public PRS1ParsedEvent
{ {
public: public:
static const PRS1ParsedEventType TYPE = EV_PRS1_RAW;
int m_pos; int m_pos;
unsigned char m_code; unsigned char m_code;
QByteArray m_data; QByteArray m_data;
PRS1UnknownDataEvent(const QByteArray & data, int pos, int len=18) PRS1UnknownDataEvent(const QByteArray & data, int pos, int len=18)
: PRS1ParsedEvent(EV_PRS1_RAW, 0) : PRS1ParsedEvent(TYPE, 0)
{ {
m_pos = pos; m_pos = pos;
m_data = data.mid(pos, len); m_data = data.mid(pos, len);
@ -1251,195 +1264,112 @@ public:
class PRS1ParsedSettingEvent : public PRS1ParsedValueEvent class PRS1ParsedSettingEvent : public PRS1ParsedValueEvent
{ {
public: public:
static const PRS1ParsedEventType TYPE = EV_PRS1_SETTING;
PRS1ParsedSettingType m_setting; PRS1ParsedSettingType m_setting;
PRS1ParsedSettingEvent(PRS1ParsedSettingType setting, int value) : PRS1ParsedValueEvent(EV_PRS1_SETTING, 0, value), m_setting(setting) {} PRS1ParsedSettingEvent(PRS1ParsedSettingType setting, int value) : PRS1ParsedValueEvent(TYPE, 0, value), m_setting(setting) {}
}; };
class PRS1PressureSettingEvent : public PRS1ParsedSettingEvent class PRS1PressureSettingEvent : public PRS1ParsedSettingEvent
{ {
public: public:
static constexpr float GAIN = PRS1PressureEvent::GAIN;
static const PRS1ParsedEventUnit UNIT = PRS1PressureEvent::UNIT;
PRS1PressureSettingEvent(PRS1ParsedSettingType setting, int value) PRS1PressureSettingEvent(PRS1ParsedSettingType setting, int value)
: PRS1ParsedSettingEvent(setting, value) : PRS1ParsedSettingEvent(setting, value)
{ {
m_gain = PRS1PressureEvent::GAIN; m_gain = GAIN;
m_unit = PRS1PressureEvent::UNIT; m_unit = UNIT;
} }
}; };
class PRS1ParsedSliceEvent : public PRS1ParsedDurationEvent class PRS1ParsedSliceEvent : public PRS1ParsedDurationEvent
{ {
public: public:
static const PRS1ParsedEventType TYPE = EV_PRS1_SLICE;
SliceStatus m_status; SliceStatus m_status;
PRS1ParsedSliceEvent(int start, int duration, SliceStatus status) : PRS1ParsedDurationEvent(EV_PRS1_SLICE, start, duration), m_status(status) {}
PRS1ParsedSliceEvent(int start, int duration, SliceStatus status) : PRS1ParsedDurationEvent(TYPE, start, duration), m_status(status) {}
}; };
#define _PRS1_EVENT(T, E, P, ARG) \
class T : public P \
{ \
public: \
static const PRS1ParsedEventType TYPE = E; \
T(int start, int ARG) : P(TYPE, start, ARG) {} \
}
#define PRS1_DURATION_EVENT(T, E) _PRS1_EVENT(T, E, PRS1ParsedDurationEvent, duration)
#define PRS1_VALUE_EVENT(T, E) _PRS1_EVENT(T, E, PRS1ParsedValueEvent, value)
#define PRS1_PRESSURE_EVENT(T, E) _PRS1_EVENT(T, E, PRS1PressureEvent, value)
class PRS1TimedBreathEvent : public PRS1ParsedDurationEvent PRS1_DURATION_EVENT(PRS1TimedBreathEvent, EV_PRS1_TB);
{
public:
PRS1TimedBreathEvent(int start, int duration) : PRS1ParsedDurationEvent(EV_PRS1_TB, start, duration) {}
};
class PRS1ObstructiveApneaEvent : public PRS1ParsedDurationEvent PRS1_DURATION_EVENT(PRS1ObstructiveApneaEvent, EV_PRS1_OA);
{
public:
PRS1ObstructiveApneaEvent(int start, int duration) : PRS1ParsedDurationEvent(EV_PRS1_OA, start, duration) {}
};
class PRS1ClearAirwayEvent : public PRS1ParsedDurationEvent PRS1_DURATION_EVENT(PRS1ClearAirwayEvent, EV_PRS1_CA);
{
public:
PRS1ClearAirwayEvent(int start, int duration) : PRS1ParsedDurationEvent(EV_PRS1_CA, start, duration) {}
};
class PRS1FlowLimitationEvent : public PRS1ParsedDurationEvent PRS1_DURATION_EVENT(PRS1FlowLimitationEvent, EV_PRS1_FL);
{
public:
PRS1FlowLimitationEvent(int start, int duration) : PRS1ParsedDurationEvent(EV_PRS1_FL, start, duration) {}
};
class PRS1PeriodicBreathingEvent : public PRS1ParsedDurationEvent PRS1_DURATION_EVENT(PRS1PeriodicBreathingEvent, EV_PRS1_PB);
{
public:
PRS1PeriodicBreathingEvent(int start, int duration) : PRS1ParsedDurationEvent(EV_PRS1_PB, start, duration) {}
};
class PRS1LargeLeakEvent : public PRS1ParsedDurationEvent PRS1_DURATION_EVENT(PRS1LargeLeakEvent, EV_PRS1_LL);
{
public:
PRS1LargeLeakEvent(int start, int duration) : PRS1ParsedDurationEvent(EV_PRS1_LL, start, duration) {}
};
class PRS1HypopneaEvent : public PRS1ParsedDurationEvent PRS1_DURATION_EVENT(PRS1HypopneaEvent, EV_PRS1_HY);
{
public:
PRS1HypopneaEvent(int start, int duration) : PRS1ParsedDurationEvent(EV_PRS1_HY, start, duration) {}
};
class PRS1TotalLeakEvent : public PRS1ParsedValueEvent PRS1_VALUE_EVENT(PRS1TotalLeakEvent, EV_PRS1_TOTLEAK);
{
public:
PRS1TotalLeakEvent(int start, int value) : PRS1ParsedValueEvent(EV_PRS1_TOTLEAK, start, value) {}
};
class PRS1LeakEvent : public PRS1ParsedValueEvent // TODO: do machines really report unintentional leak? PRS1_VALUE_EVENT(PRS1LeakEvent, EV_PRS1_LEAK); // TODO: do machines really report unintentional leak?
{
public:
PRS1LeakEvent(int start, int value) : PRS1ParsedValueEvent(EV_PRS1_LEAK, start, value) {}
};
class PRS1CPAPEvent : public PRS1PressureEvent PRS1_PRESSURE_EVENT(PRS1CPAPEvent, EV_PRS1_PRESSURE);
{
public:
PRS1CPAPEvent(int start, int value) : PRS1PressureEvent(EV_PRS1_PRESSURE, start, value) {}
};
class PRS1IPAPEvent : public PRS1PressureEvent PRS1_PRESSURE_EVENT(PRS1IPAPEvent, EV_PRS1_IPAP);
{
public:
PRS1IPAPEvent(int start, int value) : PRS1PressureEvent(EV_PRS1_IPAP, start, value) {}
};
class PRS1IPAPHighEvent : public PRS1PressureEvent PRS1_PRESSURE_EVENT(PRS1IPAPHighEvent, EV_PRS1_IPAPHIGH);
{
public:
PRS1IPAPHighEvent(int start, int value) : PRS1PressureEvent(EV_PRS1_IPAPHIGH, start, value) {}
};
class PRS1IPAPLowEvent : public PRS1PressureEvent PRS1_PRESSURE_EVENT(PRS1IPAPLowEvent, EV_PRS1_IPAPLOW);
{
public:
PRS1IPAPLowEvent(int start, int value) : PRS1PressureEvent(EV_PRS1_IPAPLOW, start, value) {}
};
class PRS1EPAPEvent : public PRS1PressureEvent PRS1_PRESSURE_EVENT(PRS1EPAPEvent, EV_PRS1_EPAP);
{
public:
PRS1EPAPEvent(int start, int value) : PRS1PressureEvent(EV_PRS1_EPAP, start, value) {}
};
class PRS1PressureReliefEvent : public PRS1PressureEvent // value is pressure applied during pressure relief, similar to EPAP PRS1_PRESSURE_EVENT(PRS1PressureReliefEvent, EV_PRS1_FLEX); // value is pressure applied during pressure relief, similar to EPAP
{
public:
PRS1PressureReliefEvent(int start, int value) : PRS1PressureEvent(EV_PRS1_FLEX, start, value) {}
};
class PRS1RespiratoryRateEvent : public PRS1ParsedValueEvent PRS1_VALUE_EVENT(PRS1RespiratoryRateEvent, EV_PRS1_RR);
{
public:
PRS1RespiratoryRateEvent(int start, int value) : PRS1ParsedValueEvent(EV_PRS1_RR, start, value) {}
};
class PRS1PatientTriggeredBreathsEvent : public PRS1ParsedValueEvent PRS1_VALUE_EVENT(PRS1PatientTriggeredBreathsEvent, EV_PRS1_PTB);
{
public:
PRS1PatientTriggeredBreathsEvent(int start, int value) : PRS1ParsedValueEvent(EV_PRS1_PTB, start, value) {}
};
class PRS1MinuteVentilationEvent : public PRS1ParsedValueEvent PRS1_VALUE_EVENT(PRS1MinuteVentilationEvent, EV_PRS1_MV);
{
public:
PRS1MinuteVentilationEvent(int start, int value) : PRS1ParsedValueEvent(EV_PRS1_MV, start, value) {}
};
class PRS1TidalVolumeEvent : public PRS1ParsedValueEvent class PRS1TidalVolumeEvent : public PRS1ParsedValueEvent
{ {
public: public:
static const PRS1ParsedEventType TYPE = EV_PRS1_TV;
static constexpr float GAIN = 10.0;
static const PRS1ParsedEventUnit UNIT = PRS1_UNIT_ML;
PRS1TidalVolumeEvent(int start, int value) PRS1TidalVolumeEvent(int start, int value)
: PRS1ParsedValueEvent(EV_PRS1_TV, start, value) : PRS1ParsedValueEvent(TYPE, start, value)
{ {
m_gain = 10.0; m_gain = GAIN;
m_unit = PRS1_UNIT_ML; m_unit = UNIT;
} }
}; };
class PRS1SnoreEvent : public PRS1ParsedValueEvent PRS1_VALUE_EVENT(PRS1SnoreEvent, EV_PRS1_SNORE);
{
public:
PRS1SnoreEvent(int start, int value) : PRS1ParsedValueEvent(EV_PRS1_SNORE, start, value) {}
};
class PRS1VibratorySnoreEvent : public PRS1ParsedValueEvent PRS1_VALUE_EVENT(PRS1VibratorySnoreEvent, EV_PRS1_VS);
{
public:
PRS1VibratorySnoreEvent(int start, int value) : PRS1ParsedValueEvent(EV_PRS1_VS, start, value) {}
};
class PRS1PressurePulseEvent : public PRS1ParsedValueEvent PRS1_VALUE_EVENT(PRS1PressurePulseEvent, EV_PRS1_PP);
{
public:
PRS1PressurePulseEvent(int start, int value) : PRS1ParsedValueEvent(EV_PRS1_PP, start, value) {}
};
class PRS1RERAEvent : public PRS1ParsedValueEvent // TODO: should this really be a duration event? PRS1_VALUE_EVENT(PRS1RERAEvent, EV_PRS1_RERA); // TODO: should this really be a duration event?
{
public:
PRS1RERAEvent(int start, int value) : PRS1ParsedValueEvent(EV_PRS1_RERA, start, value) {}
};
class PRS1NonRespondingEvent : public PRS1ParsedValueEvent // TODO: is this a single event or an index/hour? PRS1_VALUE_EVENT(PRS1NonRespondingEvent, EV_PRS1_NRI); // TODO: is this a single event or an index/hour?
{
public:
PRS1NonRespondingEvent(int start, int value) : PRS1ParsedValueEvent(EV_PRS1_NRI, start, value) {}
};
class PRS1FlowRateEvent : public PRS1ParsedValueEvent // TODO: is this a single event or an index/hour? PRS1_VALUE_EVENT(PRS1FlowRateEvent, EV_PRS1_FLOWRATE); // TODO: is this a single event or an index/hour?
{
public:
PRS1FlowRateEvent(int start, int value) : PRS1ParsedValueEvent(EV_PRS1_FLOWRATE, start, value) {}
};
class PRS1Test1Event : public PRS1ParsedValueEvent // TODO: replace test1/2 event with unknownvalue events and appropriate mapping PRS1_VALUE_EVENT(PRS1Test1Event, EV_PRS1_TEST1); // TODO: replace test1/2 event with unknownvalue events and appropriate mapping
{
public:
PRS1Test1Event(int start, int value) : PRS1ParsedValueEvent(EV_PRS1_TEST1, start, value) {}
};
class PRS1Test2Event : public PRS1ParsedValueEvent PRS1_VALUE_EVENT(PRS1Test2Event, EV_PRS1_TEST2);
{
public:
PRS1Test2Event(int start, int value) : PRS1ParsedValueEvent(EV_PRS1_TEST2, start, value) {}
};
void PRS1DataChunk::AddEvent(PRS1ParsedEvent* const event) void PRS1DataChunk::AddEvent(PRS1ParsedEvent* const event)
{ {
@ -1500,32 +1430,32 @@ bool PRS1Import::ParseF5EventsFV3()
t = qint64(event->timestamp + e->m_start) * 1000L; t = qint64(event->timestamp + e->m_start) * 1000L;
switch (e->m_type) { switch (e->m_type) {
case EV_PRS1_TB: case PRS1TimedBreathEvent::TYPE:
TB->AddEvent(t, e->m_duration); TB->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_OA: case PRS1ObstructiveApneaEvent::TYPE:
OA->AddEvent(t, e->m_duration); OA->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_CA: case PRS1ClearAirwayEvent::TYPE:
CA->AddEvent(t, e->m_duration); CA->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_FL: case PRS1FlowLimitationEvent::TYPE:
FL->AddEvent(t, e->m_duration); FL->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_PB: case PRS1PeriodicBreathingEvent::TYPE:
PB->AddEvent(t, e->m_duration); PB->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_LL: case PRS1LargeLeakEvent::TYPE:
LL->AddEvent(t, e->m_duration); LL->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_HY: case PRS1HypopneaEvent::TYPE:
HY->AddEvent(t, e->m_duration); HY->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_IPAP: case PRS1IPAPEvent::TYPE:
IPAP->AddEvent(t, e->m_value); IPAP->AddEvent(t, e->m_value);
currentPressure = e->m_value; currentPressure = e->m_value;
break; break;
case EV_PRS1_TOTLEAK: case PRS1TotalLeakEvent::TYPE:
TOTLEAK->AddEvent(t, e->m_value); TOTLEAK->AddEvent(t, e->m_value);
leak = e->m_value; leak = e->m_value;
if (calcLeaks) { // Much Quicker doing this here than the recalc method. if (calcLeaks) { // Much Quicker doing this here than the recalc method.
@ -1534,31 +1464,31 @@ bool PRS1Import::ParseF5EventsFV3()
LEAK->AddEvent(t, leak); LEAK->AddEvent(t, leak);
} }
break; break;
case EV_PRS1_IPAPLOW: case PRS1IPAPLowEvent::TYPE:
IPAPLo->AddEvent(t, e->m_value); IPAPLo->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_IPAPHIGH: case PRS1IPAPHighEvent::TYPE:
IPAPHi->AddEvent(t, e->m_value); IPAPHi->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_RR: case PRS1RespiratoryRateEvent::TYPE:
RR->AddEvent(t, e->m_value); RR->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_PTB: case PRS1PatientTriggeredBreathsEvent::TYPE:
PTB->AddEvent(t, e->m_value); PTB->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_MV: case PRS1MinuteVentilationEvent::TYPE:
MV->AddEvent(t, e->m_value); MV->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_TV: case PRS1TidalVolumeEvent::TYPE:
TV->AddEvent(t, e->m_value); TV->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_SNORE: case PRS1SnoreEvent::TYPE:
SNORE->AddEvent(t, e->m_value); SNORE->AddEvent(t, e->m_value);
if (e->m_value > 0) { if (e->m_value > 0) {
VS->AddEvent(t, 0); //data2); // VSnore VS->AddEvent(t, 0); //data2); // VSnore
} }
break; break;
case EV_PRS1_EPAP: case PRS1EPAPEvent::TYPE:
EPAP->AddEvent(t, e->m_value); EPAP->AddEvent(t, e->m_value);
ps = currentPressure - e->m_value; ps = currentPressure - e->m_value;
PS->AddEvent(t, ps); // Pressure Support PS->AddEvent(t, ps); // Pressure Support
@ -1793,38 +1723,38 @@ bool PRS1Import::ParseF5Events()
t = qint64(event->timestamp + e->m_start) * 1000L; t = qint64(event->timestamp + e->m_start) * 1000L;
switch (e->m_type) { switch (e->m_type) {
case EV_PRS1_TB: case PRS1TimedBreathEvent::TYPE:
TB->AddEvent(t, e->m_duration); TB->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_OA: case PRS1ObstructiveApneaEvent::TYPE:
OA->AddEvent(t, e->m_duration); OA->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_CA: case PRS1ClearAirwayEvent::TYPE:
CA->AddEvent(t, e->m_duration); CA->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_FL: case PRS1FlowLimitationEvent::TYPE:
FL->AddEvent(t, e->m_duration); FL->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_PB: case PRS1PeriodicBreathingEvent::TYPE:
PB->AddEvent(t, e->m_duration); PB->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_LL: case PRS1LargeLeakEvent::TYPE:
LL->AddEvent(t, e->m_duration); LL->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_HY: case PRS1HypopneaEvent::TYPE:
HY->AddEvent(t, e->m_duration); HY->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_IPAP: case PRS1IPAPEvent::TYPE:
IPAP->AddEvent(t, e->m_value); IPAP->AddEvent(t, e->m_value);
currentPressure = e->m_value; currentPressure = e->m_value;
break; break;
case EV_PRS1_IPAPLOW: case PRS1IPAPLowEvent::TYPE:
IPAPLo->AddEvent(t, e->m_value); IPAPLo->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_IPAPHIGH: case PRS1IPAPHighEvent::TYPE:
IPAPHi->AddEvent(t, e->m_value); IPAPHi->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_TOTLEAK: case PRS1TotalLeakEvent::TYPE:
TOTLEAK->AddEvent(t, e->m_value); TOTLEAK->AddEvent(t, e->m_value);
leak = e->m_value; leak = e->m_value;
if (calcLeaks) { // Much Quicker doing this here than the recalc method. if (calcLeaks) { // Much Quicker doing this here than the recalc method.
@ -1833,33 +1763,33 @@ bool PRS1Import::ParseF5Events()
LEAK->AddEvent(t, leak); LEAK->AddEvent(t, leak);
} }
break; break;
case EV_PRS1_LEAK: case PRS1LeakEvent::TYPE:
LEAK->AddEvent(t, e->m_value); LEAK->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_RR: case PRS1RespiratoryRateEvent::TYPE:
RR->AddEvent(t, e->m_value); RR->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_PTB: case PRS1PatientTriggeredBreathsEvent::TYPE:
PTB->AddEvent(t, e->m_value); PTB->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_MV: case PRS1MinuteVentilationEvent::TYPE:
MV->AddEvent(t, e->m_value); MV->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_TV: case PRS1TidalVolumeEvent::TYPE:
TV->AddEvent(t, e->m_value); TV->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_SNORE: case PRS1SnoreEvent::TYPE:
SNORE->AddEvent(t, e->m_value); SNORE->AddEvent(t, e->m_value);
if (e->m_value > 0) { if (e->m_value > 0) {
VS->AddEvent(t, 0); //data2); // VSnore VS->AddEvent(t, 0); //data2); // VSnore
} }
break; break;
case EV_PRS1_EPAP: case PRS1EPAPEvent::TYPE:
EPAP->AddEvent(t, e->m_value); EPAP->AddEvent(t, e->m_value);
ps = currentPressure - e->m_value; ps = currentPressure - e->m_value;
PS->AddEvent(t, ps); // Pressure Support PS->AddEvent(t, ps); // Pressure Support
break; break;
case EV_PRS1_UNKNOWN: case PRS1UnknownValueEvent::TYPE:
{ {
int code = ((PRS1UnknownValueEvent*) e)->m_code; int code = ((PRS1UnknownValueEvent*) e)->m_code;
Q_ASSERT(code < ncodes); Q_ASSERT(code < ncodes);
@ -2214,58 +2144,58 @@ bool PRS1Import::ParseF3EventsV3()
t = qint64(event->timestamp + e->m_start) * 1000L; t = qint64(event->timestamp + e->m_start) * 1000L;
switch (e->m_type) { switch (e->m_type) {
case EV_PRS1_TB: case PRS1TimedBreathEvent::TYPE:
TB->AddEvent(t, e->m_duration); TB->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_OA: case PRS1ObstructiveApneaEvent::TYPE:
OA->AddEvent(t, e->m_duration); OA->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_CA: case PRS1ClearAirwayEvent::TYPE:
CA->AddEvent(t, e->m_duration); CA->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_PB: case PRS1PeriodicBreathingEvent::TYPE:
PB->AddEvent(t, e->m_duration); PB->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_LL: case PRS1LargeLeakEvent::TYPE:
LL->AddEvent(t, e->m_duration); LL->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_HY: case PRS1HypopneaEvent::TYPE:
HY->AddEvent(t, e->m_duration); HY->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_EPAP: case PRS1EPAPEvent::TYPE:
EPAP->AddEvent(t, e->m_value); EPAP->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_IPAP: case PRS1IPAPEvent::TYPE:
IPAP->AddEvent(t, e->m_value); IPAP->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_LEAK: case PRS1LeakEvent::TYPE:
LEAK->AddEvent(t, e->m_value); LEAK->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_RR: case PRS1RespiratoryRateEvent::TYPE:
RR->AddEvent(t, e->m_value); RR->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_PTB: case PRS1PatientTriggeredBreathsEvent::TYPE:
PTB->AddEvent(t, e->m_value); PTB->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_MV: case PRS1MinuteVentilationEvent::TYPE:
MV->AddEvent(t, e->m_value); MV->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_TV: case PRS1TidalVolumeEvent::TYPE:
TV->AddEvent(t, e->m_value); TV->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_RERA: case PRS1RERAEvent::TYPE:
RE->AddEvent(t, e->m_value); RE->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_NRI: case PRS1NonRespondingEvent::TYPE:
ZZ->AddEvent(t, e->m_value); ZZ->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_TEST1: case PRS1Test1Event::TYPE:
TMV->AddEvent(t, e->m_value); TMV->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_TEST2: case PRS1Test2Event::TYPE:
FLOW->AddEvent(t, e->m_value); FLOW->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_RAW: case PRS1UnknownDataEvent::TYPE:
{ {
PRS1UnknownDataEvent* unk = (PRS1UnknownDataEvent*) e; PRS1UnknownDataEvent* unk = (PRS1UnknownDataEvent*) e;
int code = unk->m_code; int code = unk->m_code;
@ -2438,40 +2368,40 @@ bool PRS1Import::ParseF3Events()
t = qint64(event->timestamp + e->m_start) * 1000L; t = qint64(event->timestamp + e->m_start) * 1000L;
switch (e->m_type) { switch (e->m_type) {
case EV_PRS1_OA: case PRS1ObstructiveApneaEvent::TYPE:
OA->AddEvent(t, e->m_duration); OA->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_CA: case PRS1ClearAirwayEvent::TYPE:
CA->AddEvent(t, e->m_duration); CA->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_HY: case PRS1HypopneaEvent::TYPE:
HY->AddEvent(t, e->m_duration); HY->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_EPAP: case PRS1EPAPEvent::TYPE:
EPAP->AddEvent(t, e->m_value); EPAP->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_IPAP: case PRS1IPAPEvent::TYPE:
IPAP->AddEvent(t, e->m_value); IPAP->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_TOTLEAK: case PRS1TotalLeakEvent::TYPE:
TOTLEAK->AddEvent(t, e->m_value); TOTLEAK->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_LEAK: case PRS1LeakEvent::TYPE:
LEAK->AddEvent(t, e->m_value); LEAK->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_RR: case PRS1RespiratoryRateEvent::TYPE:
RR->AddEvent(t, e->m_value); RR->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_PTB: case PRS1PatientTriggeredBreathsEvent::TYPE:
PTB->AddEvent(t, e->m_value); PTB->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_MV: case PRS1MinuteVentilationEvent::TYPE:
MV->AddEvent(t, e->m_value); MV->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_TV: case PRS1TidalVolumeEvent::TYPE:
TV->AddEvent(t, e->m_value); TV->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_FLOWRATE: case PRS1FlowRateEvent::TYPE:
FLOW->AddEvent(t, e->m_value); FLOW->AddEvent(t, e->m_value);
break; break;
default: default:
@ -2695,21 +2625,21 @@ bool PRS1Import::ParseF0Events()
t = qint64(event->timestamp + e->m_start) * 1000L; t = qint64(event->timestamp + e->m_start) * 1000L;
switch (e->m_type) { switch (e->m_type) {
case EV_PRS1_PRESSURE: case PRS1CPAPEvent::TYPE:
if (!PRESSURE) { if (!PRESSURE) {
if (!(PRESSURE = session->AddEventList(CPAP_Pressure, EVL_Event, e->m_gain))) { return false; } if (!(PRESSURE = session->AddEventList(CPAP_Pressure, EVL_Event, e->m_gain))) { return false; }
} }
PRESSURE->AddEvent(t, e->m_value); PRESSURE->AddEvent(t, e->m_value);
currentPressure = e->m_value; currentPressure = e->m_value;
break; break;
case EV_PRS1_IPAP: case PRS1IPAPEvent::TYPE:
if(!IPAP) { if(!IPAP) {
if (!(IPAP = session->AddEventList(CPAP_IPAP, EVL_Event, e->m_gain))) { return false; } if (!(IPAP = session->AddEventList(CPAP_IPAP, EVL_Event, e->m_gain))) { return false; }
} }
IPAP->AddEvent(t, e->m_value); IPAP->AddEvent(t, e->m_value);
currentPressure = e->m_value; currentPressure = e->m_value;
break; break;
case EV_PRS1_EPAP: case PRS1EPAPEvent::TYPE:
if (!EPAP) { if (!EPAP) {
if (!(EPAP = session->AddEventList(CPAP_EPAP, EVL_Event, e->m_gain))) { return false; } if (!(EPAP = session->AddEventList(CPAP_EPAP, EVL_Event, e->m_gain))) { return false; }
} }
@ -2719,31 +2649,31 @@ bool PRS1Import::ParseF0Events()
EPAP->AddEvent(t, e->m_value); EPAP->AddEvent(t, e->m_value);
PS->AddEvent(t, currentPressure - e->m_value); PS->AddEvent(t, currentPressure - e->m_value);
break; break;
case EV_PRS1_FLEX: case PRS1PressureReliefEvent::TYPE:
if (!EPAP) { if (!EPAP) {
if (!(EPAP = session->AddEventList(CPAP_EPAP, EVL_Event, e->m_gain))) { return false; } if (!(EPAP = session->AddEventList(CPAP_EPAP, EVL_Event, e->m_gain))) { return false; }
} }
EPAP->AddEvent(t, e->m_value); EPAP->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_OA: case PRS1ObstructiveApneaEvent::TYPE:
OA->AddEvent(t, e->m_duration); OA->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_CA: case PRS1ClearAirwayEvent::TYPE:
CA->AddEvent(t, e->m_duration); CA->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_FL: case PRS1FlowLimitationEvent::TYPE:
FL->AddEvent(t, e->m_duration); FL->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_PB: case PRS1PeriodicBreathingEvent::TYPE:
PB->AddEvent(t, e->m_duration); PB->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_LL: case PRS1LargeLeakEvent::TYPE:
LL->AddEvent(t, e->m_duration); LL->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_HY: case PRS1HypopneaEvent::TYPE:
HY->AddEvent(t, e->m_duration); HY->AddEvent(t, e->m_duration);
break; break;
case EV_PRS1_TOTLEAK: case PRS1TotalLeakEvent::TYPE:
TOTLEAK->AddEvent(t, e->m_value); TOTLEAK->AddEvent(t, e->m_value);
leak = e->m_value; leak = e->m_value;
if (calcLeaks) { // Much Quicker doing this here than the recalc method. if (calcLeaks) { // Much Quicker doing this here than the recalc method.
@ -2752,22 +2682,22 @@ bool PRS1Import::ParseF0Events()
LEAK->AddEvent(t, leak); LEAK->AddEvent(t, leak);
} }
break; break;
case EV_PRS1_SNORE: case PRS1SnoreEvent::TYPE:
SNORE->AddEvent(t, e->m_value); SNORE->AddEvent(t, e->m_value);
if (e->m_value > 0) { if (e->m_value > 0) {
VS2->AddEvent(t, e->m_value); VS2->AddEvent(t, e->m_value);
} }
break; break;
case EV_PRS1_VS: // F0: Is this really distinct from SNORE and VS2? case PRS1VibratorySnoreEvent::TYPE: // F0: Is this really distinct from SNORE and VS2?
VS->AddEvent(t, 0); VS->AddEvent(t, 0);
break; break;
case EV_PRS1_RERA: case PRS1RERAEvent::TYPE:
RE->AddEvent(t, e->m_value); RE->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_PP: case PRS1PressurePulseEvent::TYPE:
PP->AddEvent(t, e->m_value); PP->AddEvent(t, e->m_value);
break; break;
case EV_PRS1_UNKNOWN: case PRS1UnknownValueEvent::TYPE:
{ {
int code = ((PRS1UnknownValueEvent*) e)->m_code; int code = ((PRS1UnknownValueEvent*) e)->m_code;
Q_ASSERT(code < ncodes); Q_ASSERT(code < ncodes);
@ -3031,14 +2961,14 @@ bool PRS1Import::ParseCompliance()
for (int i=0; i < compliance->m_parsedData.count(); i++) { for (int i=0; i < compliance->m_parsedData.count(); i++) {
PRS1ParsedEvent* e = compliance->m_parsedData.at(i); PRS1ParsedEvent* e = compliance->m_parsedData.at(i);
if (e->m_type == EV_PRS1_SLICE) { if (e->m_type == PRS1ParsedSliceEvent::TYPE) {
PRS1ParsedSliceEvent* s = (PRS1ParsedSliceEvent*) e; PRS1ParsedSliceEvent* s = (PRS1ParsedSliceEvent*) e;
qint64 tt = start + qint64(s->m_start) * 1000L; qint64 tt = start + qint64(s->m_start) * 1000L;
qint64 duration = qint64(s->m_duration) * 1000L; qint64 duration = qint64(s->m_duration) * 1000L;
session->m_slices.append(SessionSlice(tt, tt + duration, s->m_status)); session->m_slices.append(SessionSlice(tt, tt + duration, s->m_status));
qDebug() << compliance->sessionid << "Added Slice" << tt << (tt+duration) << s->m_status; qDebug() << compliance->sessionid << "Added Slice" << tt << (tt+duration) << s->m_status;
continue; continue;
} else if (e->m_type != EV_PRS1_SETTING) { } else if (e->m_type != PRS1ParsedSettingEvent::TYPE) {
qWarning() << "Compliance had non-setting event:" << (int) e->m_type; qWarning() << "Compliance had non-setting event:" << (int) e->m_type;
continue; continue;
} }
@ -3642,7 +3572,7 @@ bool PRS1Import::ImportSummary()
for (int i=0; i < summary->m_parsedData.count(); i++) { for (int i=0; i < summary->m_parsedData.count(); i++) {
PRS1ParsedEvent* e = summary->m_parsedData.at(i); PRS1ParsedEvent* e = summary->m_parsedData.at(i);
if (e->m_type != EV_PRS1_SETTING) { if (e->m_type != PRS1ParsedSettingEvent::TYPE) {
qWarning() << "Summary had non-setting event:" << (int) e->m_type; qWarning() << "Summary had non-setting event:" << (int) e->m_type;
continue; continue;
} }