Index: sources/view/hd/data/treatment/VHDTreatmentStatesData.cpp =================================================================== diff -u -r79a6cfcb10472261f3ec26eaf0baf6f1245cd311 -rb3a919eb1696079530d537fb2bf8b7e526178997 --- sources/view/hd/data/treatment/VHDTreatmentStatesData.cpp (.../VHDTreatmentStatesData.cpp) (revision 79a6cfcb10472261f3ec26eaf0baf6f1245cd311) +++ sources/view/hd/data/treatment/VHDTreatmentStatesData.cpp (.../VHDTreatmentStatesData.cpp) (revision b3a919eb1696079530d537fb2bf8b7e526178997) @@ -13,10 +13,21 @@ * */ #include "VHDTreatmentStatesData.h" +#include // Project #include "GuiController.h" +//ENUM Checks +//TODO: ---------- Improve me ---------- +// This part of the code is a WIP example to fail the build if the enum is changed but UI doesn't aware. +#define ENUM_PRINT( vTYPE ) {} // qDebug() << v##vTYPE +#define ENUM_CHECK_O( vTYPE, vVALUE ) vTYPE v##vTYPE = static_cast(vVALUE); switch(v##vTYPE) +#define ENUM_CHECK( vTYPE, vENUM ) case vTYPE::vENUM : { if ( vTYPE::vENUM == v##vTYPE) ENUM_PRINT(vTYPE); } break; +#define ENUM_CHECK_C( vTYPE, vENUM ) case vTYPE::vENUM : break; +#define ENUM_READ( vTYPE, vENUM, vSTATE ) vSTATE( vTYPE::vENUM == v##vTYPE); + + VIEW_DEF_CLASS(VHDTreatmentStates) /*! @@ -50,41 +61,71 @@ salineState ( vData.mSalineState ); // Ultrafiltration states - ufStart ( vData.mUFState == GuiUFStates ::UF_START_STATE ); - ufPaused ( vData.mUFState == GuiUFStates ::UF_PAUSED_STATE ); - ufRunning ( vData.mUFState == GuiUFStates ::UF_RUNNING_STATE ); + ENUM_CHECK_O( GuiUFStates, vData.mUFState ) { + ENUM_CHECK ( GuiUFStates, UF_START_STATE ) + ENUM_CHECK ( GuiUFStates, UF_PAUSED_STATE ) + ENUM_CHECK ( GuiUFStates, UF_RUNNING_STATE ) + ENUM_CHECK_C( GuiUFStates, NUM_OF_UF_STATES ) } + ENUM_READ ( GuiUFStates, UF_START_STATE , ufStart ); + ENUM_READ ( GuiUFStates, UF_PAUSED_STATE , ufPaused ); + ENUM_READ ( GuiUFStates, UF_RUNNING_STATE, ufRunning ); // Saline Bolus states - sbIdle ( vData.mSalineState == GuiSalineStates ::SALINE_BOLUS_STATE_IDLE ); - sbWaitPump ( vData.mSalineState == GuiSalineStates ::SALINE_BOLUS_STATE_WAIT_FOR_PUMPS_STOP ); - sbRunning ( vData.mSalineState == GuiSalineStates ::SALINE_BOLUS_STATE_IN_PROGRESS ); - sbMaxReached ( vData.mSalineState == GuiSalineStates ::SALINE_BOLUS_STATE_MAX_DELIVERED ); + ENUM_CHECK_O( GuiSalineStates, vData.mSalineState ) { + ENUM_CHECK ( GuiSalineStates, SALINE_BOLUS_STATE_IDLE ) + ENUM_CHECK ( GuiSalineStates, SALINE_BOLUS_STATE_WAIT_FOR_PUMPS_STOP ) + ENUM_CHECK ( GuiSalineStates, SALINE_BOLUS_STATE_IN_PROGRESS ) + ENUM_CHECK ( GuiSalineStates, SALINE_BOLUS_STATE_MAX_DELIVERED ) + ENUM_CHECK_C( GuiSalineStates, NUM_OF_SALINE_BOLUS_STATES ) } + ENUM_READ ( GuiSalineStates, SALINE_BOLUS_STATE_IDLE , sbIdle ); + ENUM_READ ( GuiSalineStates, SALINE_BOLUS_STATE_WAIT_FOR_PUMPS_STOP , sbWaitPump ); + ENUM_READ ( GuiSalineStates, SALINE_BOLUS_STATE_IN_PROGRESS , sbRunning ); + ENUM_READ ( GuiSalineStates, SALINE_BOLUS_STATE_MAX_DELIVERED , sbMaxReached ); // Heparin States _heparin = false; - hpOff ( vData.mHeparinState == GuiHeparinStates ::HEPARIN_STATE_OFF ); _heparin = _heparin || _hpOff ; - hpStopped ( vData.mHeparinState == GuiHeparinStates ::HEPARIN_STATE_STOPPED ); _heparin = _heparin || _hpStopped ; - hpPaused ( vData.mHeparinState == GuiHeparinStates ::HEPARIN_STATE_PAUSED ); _heparin = _heparin || _hpPaused ; - hpInitial_bolus ( vData.mHeparinState == GuiHeparinStates ::HEPARIN_STATE_INITIAL_BOLUS ); _heparin = _heparin || _hpInitial_bolus ; - hpDispensing ( vData.mHeparinState == GuiHeparinStates ::HEPARIN_STATE_DISPENSING ); _heparin = _heparin || _hpDispensing ; - hpCompleted ( vData.mHeparinState == GuiHeparinStates ::HEPARIN_STATE_COMPLETED ); _heparin = _heparin || _hpCompleted ; - hpEmpty ( vData.mHeparinState == GuiHeparinStates ::HEPARIN_STATE_EMPTY ); _heparin = _heparin || _hpEmpty ; + ENUM_CHECK_O( GuiHeparinStates, vData.mHeparinState ) { + ENUM_CHECK ( GuiHeparinStates, HEPARIN_STATE_OFF ) + ENUM_CHECK ( GuiHeparinStates, HEPARIN_STATE_STOPPED ) + ENUM_CHECK ( GuiHeparinStates, HEPARIN_STATE_PAUSED ) + ENUM_CHECK ( GuiHeparinStates, HEPARIN_STATE_INITIAL_BOLUS ) + ENUM_CHECK ( GuiHeparinStates, HEPARIN_STATE_DISPENSING ) + ENUM_CHECK ( GuiHeparinStates, HEPARIN_STATE_COMPLETED ) + ENUM_CHECK ( GuiHeparinStates, HEPARIN_STATE_EMPTY ) + ENUM_CHECK_C( GuiHeparinStates, NUM_OF_HEPARIN_STATES ) } + ENUM_READ ( GuiHeparinStates, HEPARIN_STATE_OFF , hpOff ); _heparin = _heparin || _hpOff ; + ENUM_READ ( GuiHeparinStates, HEPARIN_STATE_STOPPED , hpStopped ); _heparin = _heparin || _hpStopped ; + ENUM_READ ( GuiHeparinStates, HEPARIN_STATE_PAUSED , hpPaused ); _heparin = _heparin || _hpPaused ; + ENUM_READ ( GuiHeparinStates, HEPARIN_STATE_INITIAL_BOLUS , hpInitial_bolus ); _heparin = _heparin || _hpInitial_bolus ; + ENUM_READ ( GuiHeparinStates, HEPARIN_STATE_DISPENSING , hpDispensing ); _heparin = _heparin || _hpDispensing ; + ENUM_READ ( GuiHeparinStates, HEPARIN_STATE_COMPLETED , hpCompleted ); _heparin = _heparin || _hpCompleted ; + ENUM_READ ( GuiHeparinStates, HEPARIN_STATE_EMPTY , hpEmpty ); _heparin = _heparin || _hpEmpty ; emit heparinChanged(_heparin); // Treatment states + ENUM_CHECK_O( GuiTreatmentStates, vData.mSubMode ) { + ENUM_CHECK ( GuiTreatmentStates, TREATMENT_START_STATE ) + ENUM_CHECK ( GuiTreatmentStates, TREATMENT_BLOOD_PRIME_STATE ) + ENUM_CHECK ( GuiTreatmentStates, TREATMENT_DIALYSIS_STATE ) + ENUM_CHECK ( GuiTreatmentStates, TREATMENT_STOP_STATE ) + ENUM_CHECK ( GuiTreatmentStates, TREATMENT_RINSEBACK_STATE ) + ENUM_CHECK ( GuiTreatmentStates, TREATMENT_RECIRC_STATE ) + ENUM_CHECK ( GuiTreatmentStates, TREATMENT_END_STATE ) + ENUM_CHECK_C( GuiTreatmentStates, NUM_OF_TREATMENT_STATES ) } // Treatment states - Basics - txStart ( vData.mSubMode == GuiTreatmentStates ::TREATMENT_START_STATE ); + ENUM_READ ( GuiTreatmentStates, TREATMENT_START_STATE , txStart ); // Treatment states - Dialysis - txDialysis ( vData.mSubMode == GuiTreatmentStates ::TREATMENT_DIALYSIS_STATE ); + ENUM_READ ( GuiTreatmentStates, TREATMENT_DIALYSIS_STATE , txDialysis ); + // TODO : Check with Qt.5.15.10 // NOTE : For Rinseback and Recirculate // 1 - it seems we may never need the txRinseback // since in the Rinseback state parameter of the Treatment State the first state of each has the same meaning // it may only be used to know when those parameters have valid values to update the properties. // Kept for now because cannot be sure that it will change later or not. // 2 - if there could be a way to export enums to qml and qml can raise an error if an incorrect enum used, - // then it would is absolutely preferred to use enum instead of properties + // then it would be absolutely preferred to use enum instead of properties // currently if just one property being defined/used to send the current state to the qml, there is no way to make sure if incorrect/undefined // enum is used or not. // in Qt user/developer can literally type GuiActions.abcdefg and qml will never complain and only if compared with the state will return false. @@ -93,42 +134,68 @@ // Rinseback states bool mRinseback = vData.mSubMode == GuiTreatmentStates ::TREATMENT_RINSEBACK_STATE ; if ( mRinseback ) { - rbInit ( vData.mRinsebackState == GuiRinsebackStates ::RINSEBACK_STOP_INIT_STATE ); - rbRun ( vData.mRinsebackState == GuiRinsebackStates ::RINSEBACK_RUN_STATE ); - rbPaused ( vData.mRinsebackState == GuiRinsebackStates ::RINSEBACK_PAUSED_STATE ); - rbStop ( vData.mRinsebackState == GuiRinsebackStates ::RINSEBACK_STOP_STATE ); - rbAdditional ( vData.mRinsebackState == GuiRinsebackStates ::RINSEBACK_RUN_ADDITIONAL_STATE ); + ENUM_CHECK_O( GuiRinsebackStates, vData.mRinsebackState ) { + ENUM_CHECK ( GuiRinsebackStates, RINSEBACK_STOP_INIT_STATE ) + ENUM_CHECK ( GuiRinsebackStates, RINSEBACK_RUN_STATE ) + ENUM_CHECK ( GuiRinsebackStates, RINSEBACK_PAUSED_STATE ) + ENUM_CHECK ( GuiRinsebackStates, RINSEBACK_STOP_STATE ) + ENUM_CHECK ( GuiRinsebackStates, RINSEBACK_RUN_ADDITIONAL_STATE ) + ENUM_CHECK_C( GuiRinsebackStates, NUM_OF_RINSEBACK_STATES ) } + ENUM_READ ( GuiRinsebackStates, RINSEBACK_STOP_INIT_STATE , rbInit ); + ENUM_READ ( GuiRinsebackStates, RINSEBACK_RUN_STATE , rbRun ); + ENUM_READ ( GuiRinsebackStates, RINSEBACK_PAUSED_STATE , rbPaused ); + ENUM_READ ( GuiRinsebackStates, RINSEBACK_STOP_STATE , rbStop ); + ENUM_READ ( GuiRinsebackStates, RINSEBACK_RUN_ADDITIONAL_STATE , rbAdditional ); } txRinseback ( mRinseback ); // it's the main rinseback even so moved last to have all the sub-rinseback-states updated prior to. // Recirculate states bool mRecirculate = vData.mSubMode == GuiTreatmentStates ::TREATMENT_RECIRC_STATE ; if ( mRecirculate ) { - rcStarted ( vData.mRecirculateState == GuiRecirculateStates ::TREATMENT_RECIRC_RECIRC_STATE ); - rcStopped ( vData.mRecirculateState == GuiRecirculateStates ::TREATMENT_RECIRC_STOPPED_STATE ); + ENUM_CHECK_O( GuiRecirculateStates, vData.mRecirculateState ) { + ENUM_CHECK ( GuiRecirculateStates, TREATMENT_RECIRC_RECIRC_STATE ) + ENUM_CHECK ( GuiRecirculateStates, TREATMENT_RECIRC_STOPPED_STATE ) + ENUM_CHECK_C( GuiRecirculateStates, NUM_OF_TREATMENT_RECIRC_STATES ) } + ENUM_READ ( GuiRecirculateStates, TREATMENT_RECIRC_RECIRC_STATE , rcStarted ); + ENUM_READ ( GuiRecirculateStates, TREATMENT_RECIRC_STOPPED_STATE , rcStopped ); } txRecirculate ( mRecirculate ); // it's the main recirculate even so moved last to have all the sub-recirculate-states updated prior to. // Blood Prime states bool mBloodPrime = vData.mSubMode == GuiTreatmentStates ::TREATMENT_BLOOD_PRIME_STATE ; if ( mBloodPrime ) { - bpRamp ( vData.mBloodPrimeState == GuiBloodPrimeStates ::BLOOD_PRIME_RAMP_STATE ); + ENUM_CHECK_O( GuiBloodPrimeStates, vData.mBloodPrimeState ) { + ENUM_CHECK ( GuiBloodPrimeStates, BLOOD_PRIME_RAMP_STATE ) + ENUM_CHECK_C( GuiBloodPrimeStates, NUM_OF_BLOOD_PRIME_STATES ) } + ENUM_READ ( GuiBloodPrimeStates, BLOOD_PRIME_RAMP_STATE , bpRamp ); } txBloodPrime ( mBloodPrime ); // Treatment End states bool mTreatmentEnd = vData.mSubMode == GuiTreatmentStates ::TREATMENT_END_STATE ; if ( mTreatmentEnd ) { - teWaitRinseback ( vData.mTreatmentEndState == GuiTreatmentEndStates ::TREATMENT_END_WAIT_FOR_RINSEBACK_STATE ); - tePaused ( vData.mTreatmentEndState == GuiTreatmentEndStates ::TREATMENT_END_PAUSED_STATE ); + ENUM_CHECK_O( GuiTreatmentEndStates, vData.mTreatmentEndState ) { + ENUM_CHECK ( GuiTreatmentEndStates, TREATMENT_END_WAIT_FOR_RINSEBACK_STATE ) + ENUM_CHECK ( GuiTreatmentEndStates, TREATMENT_END_PAUSED_STATE ) + ENUM_CHECK_C( GuiTreatmentEndStates, NUM_OF_TREATMENT_END_STATES ) } + ENUM_READ ( GuiTreatmentEndStates, TREATMENT_END_WAIT_FOR_RINSEBACK_STATE , teWaitRinseback ); + ENUM_READ ( GuiTreatmentEndStates, TREATMENT_END_PAUSED_STATE , tePaused ); } txEnd ( mTreatmentEnd ); // Treatment Stop states bool mTreatmentStop = vData.mSubMode == GuiTreatmentStates ::TREATMENT_STOP_STATE ; if ( mTreatmentStop ) { - tsRecirculate ( vData.mTreatmentStopState == GuiTreatmentStopStates ::TREATMENT_STOP_RECIRC_STATE ); - tsRecirculateNo ( vData.mTreatmentStopState == GuiTreatmentStopStates ::TREATMENT_STOP_NO_RECIRC_STATE ); + ENUM_CHECK_O( GuiTreatmentStopStates , vData.mTreatmentStopState ) { + ENUM_CHECK ( GuiTreatmentStopStates , TREATMENT_STOP_RECIRC_STATE ) + ENUM_CHECK ( GuiTreatmentStopStates , TREATMENT_STOP_RECIRC_DIALYSATE_ONLY_STATE ) + ENUM_CHECK ( GuiTreatmentStopStates , TREATMENT_STOP_RECIRC_BLOOD_ONLY_STATE ) + ENUM_CHECK ( GuiTreatmentStopStates , TREATMENT_STOP_NO_RECIRC_STATE ) + ENUM_CHECK_C( GuiTreatmentStopStates , NUM_OF_TREATMENT_STOP_STATES ) } + ENUM_READ ( GuiTreatmentStopStates , TREATMENT_STOP_RECIRC_STATE , tsRecirculate ) + ENUM_READ ( GuiTreatmentStopStates , TREATMENT_STOP_RECIRC_DIALYSATE_ONLY_STATE, tsRecirculateDialysate ) + ENUM_READ ( GuiTreatmentStopStates , TREATMENT_STOP_RECIRC_BLOOD_ONLY_STATE , tsRecirculateBlood ) + ENUM_READ ( GuiTreatmentStopStates , TREATMENT_STOP_NO_RECIRC_STATE , tsRecirculateNo ) } txStop ( mTreatmentStop ); } @@ -141,7 +208,12 @@ void VHDTreatmentStates::onActionReceive(const AdjustUltrafiltrationStateResponseData &vData) { // Ultrafiltration states - ufStart ( vData.mState == GuiUFStates ::UF_START_STATE ); - ufPaused ( vData.mState == GuiUFStates ::UF_PAUSED_STATE ); - ufRunning ( vData.mState == GuiUFStates ::UF_RUNNING_STATE ); + ENUM_CHECK_O( GuiUFStates, vData.mUFState ) { + ENUM_CHECK ( GuiUFStates, UF_START_STATE ) + ENUM_CHECK ( GuiUFStates, UF_PAUSED_STATE ) + ENUM_CHECK ( GuiUFStates, UF_RUNNING_STATE ) + ENUM_CHECK_C( GuiUFStates, NUM_OF_UF_STATES ) } + ENUM_READ ( GuiUFStates, UF_START_STATE , ufStart ); + ENUM_READ ( GuiUFStates, UF_PAUSED_STATE , ufPaused ); + ENUM_READ ( GuiUFStates, UF_RUNNING_STATE, ufRunning ); }