/**************************************************************************** ** Meta object code from reading C++ file 'VPostTreatmentAdjustTreatmentLog.h' ** ** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.10) ** ** WARNING! All changes made in this file will be lost! *****************************************************************************/ #include #include "../luis/application/sources/view/td/adjustment/posttreatment/VPostTreatmentAdjustTreatmentLog.h" #include #include #if !defined(Q_MOC_OUTPUT_REVISION) #error "The header file 'VPostTreatmentAdjustTreatmentLog.h' doesn't include ." #elif Q_MOC_OUTPUT_REVISION != 67 #error "This file was generated using the moc from 5.15.10. It" #error "cannot be used with the include files from this version of Qt." #error "(The moc has changed too much.)" #endif QT_BEGIN_MOC_NAMESPACE QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED struct qt_meta_stringdata_View__VPostTreatmentAdjustmentTreatmentLog_t { QByteArrayData data[203]; char stringdata0[4484]; }; #define QT_MOC_LITERAL(idx, ofs, len) \ Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \ qptrdiff(offsetof(qt_meta_stringdata_View__VPostTreatmentAdjustmentTreatmentLog_t, stringdata0) + ofs \ - idx * sizeof(QByteArrayData)) \ ) static const qt_meta_stringdata_View__VPostTreatmentAdjustmentTreatmentLog_t qt_meta_stringdata_View__VPostTreatmentAdjustmentTreatmentLog = { { QT_MOC_LITERAL(0, 0, 42), // "View::VPostTreatmentAdjustmen..." QT_MOC_LITERAL(1, 43, 19), // "adjustmentTriggered" QT_MOC_LITERAL(2, 63, 0), // "" QT_MOC_LITERAL(3, 64, 11), // "vadjustment" QT_MOC_LITERAL(4, 76, 16), // "patientIDChanged" QT_MOC_LITERAL(5, 93, 10), // "vpatientID" QT_MOC_LITERAL(6, 104, 20), // "bloodFlowRateChanged" QT_MOC_LITERAL(7, 125, 14), // "vbloodFlowRate" QT_MOC_LITERAL(8, 140, 26), // "bloodFlowRateActualChanged" QT_MOC_LITERAL(9, 167, 20), // "vbloodFlowRateActual" QT_MOC_LITERAL(10, 188, 24), // "dialysateFlowRateChanged" QT_MOC_LITERAL(11, 213, 18), // "vdialysateFlowRate" QT_MOC_LITERAL(12, 232, 30), // "dialysateFlowRateActualChanged" QT_MOC_LITERAL(13, 263, 24), // "vdialysateFlowRateActual" QT_MOC_LITERAL(14, 288, 24), // "treatmentDurationChanged" QT_MOC_LITERAL(15, 313, 18), // "vtreatmentDuration" QT_MOC_LITERAL(16, 332, 30), // "treatmentDurationActualChanged" QT_MOC_LITERAL(17, 363, 24), // "vtreatmentDurationActual" QT_MOC_LITERAL(18, 388, 26), // "acidConcentrateTypeChanged" QT_MOC_LITERAL(19, 415, 20), // "vacidConcentrateType" QT_MOC_LITERAL(20, 436, 32), // "acidConcentrateTypeActualChanged" QT_MOC_LITERAL(21, 469, 26), // "vacidConcentrateTypeActual" QT_MOC_LITERAL(22, 496, 31), // "bicarbonateCartridgeSizeChanged" QT_MOC_LITERAL(23, 528, 25), // "vbicarbonateCartridgeSize" QT_MOC_LITERAL(24, 554, 37), // "bicarbonateCartridgeSizeActua..." QT_MOC_LITERAL(25, 592, 31), // "vbicarbonateCartridgeSizeActual" QT_MOC_LITERAL(26, 624, 29), // "potassiumConcentrationChanged" QT_MOC_LITERAL(27, 654, 23), // "vpotassiumConcentration" QT_MOC_LITERAL(28, 678, 35), // "potassiumConcentrationActualC..." QT_MOC_LITERAL(29, 714, 29), // "vpotassiumConcentrationActual" QT_MOC_LITERAL(30, 744, 27), // "calciumConcentrationChanged" QT_MOC_LITERAL(31, 772, 21), // "vcalciumConcentration" QT_MOC_LITERAL(32, 794, 33), // "calciumConcentrationActualCha..." QT_MOC_LITERAL(33, 828, 27), // "vcalciumConcentrationActual" QT_MOC_LITERAL(34, 856, 31), // "bicarbonateConcentrationChanged" QT_MOC_LITERAL(35, 888, 25), // "vbicarbonateConcentration" QT_MOC_LITERAL(36, 914, 37), // "bicarbonateConcentrationActua..." QT_MOC_LITERAL(37, 952, 31), // "vbicarbonateConcentrationActual" QT_MOC_LITERAL(38, 984, 26), // "sodiumConcentrationChanged" QT_MOC_LITERAL(39, 1011, 20), // "vsodiumConcentration" QT_MOC_LITERAL(40, 1032, 32), // "sodiumConcentrationActualChanged" QT_MOC_LITERAL(41, 1065, 26), // "vsodiumConcentrationActual" QT_MOC_LITERAL(42, 1092, 21), // "vitalsIntervalChanged" QT_MOC_LITERAL(43, 1114, 15), // "vvitalsInterval" QT_MOC_LITERAL(44, 1130, 27), // "vitalsIntervalActualChanged" QT_MOC_LITERAL(45, 1158, 21), // "vvitalsIntervalActual" QT_MOC_LITERAL(46, 1180, 19), // "dialyzerTypeChanged" QT_MOC_LITERAL(47, 1200, 13), // "vdialyzerType" QT_MOC_LITERAL(48, 1214, 26), // "treatmentStartEpochChanged" QT_MOC_LITERAL(49, 1241, 20), // "vtreatmentStartEpoch" QT_MOC_LITERAL(50, 1262, 24), // "treatmentEndEpochChanged" QT_MOC_LITERAL(51, 1287, 18), // "vtreatmentEndEpoch" QT_MOC_LITERAL(52, 1306, 23), // "fluidBolusVolumeChanged" QT_MOC_LITERAL(53, 1330, 17), // "vfluidBolusVolume" QT_MOC_LITERAL(54, 1348, 29), // "fluidBolusVolumeActualChanged" QT_MOC_LITERAL(55, 1378, 23), // "vfluidBolusVolumeActual" QT_MOC_LITERAL(56, 1402, 18), // "heparinTypeChanged" QT_MOC_LITERAL(57, 1421, 12), // "vheparinType" QT_MOC_LITERAL(58, 1434, 30), // "heparinDeliveryDurationChanged" QT_MOC_LITERAL(59, 1465, 24), // "vheparinDeliveryDuration" QT_MOC_LITERAL(60, 1490, 36), // "heparinDeliveryDurationActual..." QT_MOC_LITERAL(61, 1527, 30), // "vheparinDeliveryDurationActual" QT_MOC_LITERAL(62, 1558, 24), // "treatmentModalityChanged" QT_MOC_LITERAL(63, 1583, 18), // "vtreatmentModality" QT_MOC_LITERAL(64, 1602, 30), // "treatmentModalityActualChanged" QT_MOC_LITERAL(65, 1633, 24), // "vtreatmentModalityActual" QT_MOC_LITERAL(66, 1658, 23), // "hDFOperatingModeChanged" QT_MOC_LITERAL(67, 1682, 17), // "vhDFOperatingMode" QT_MOC_LITERAL(68, 1700, 29), // "hDFOperatingModeActualChanged" QT_MOC_LITERAL(69, 1730, 23), // "vhDFOperatingModeActual" QT_MOC_LITERAL(70, 1754, 22), // "hepatitisStatusChanged" QT_MOC_LITERAL(71, 1777, 16), // "vhepatitisStatus" QT_MOC_LITERAL(72, 1794, 27), // "dialysateTemperatureChanged" QT_MOC_LITERAL(73, 1822, 21), // "vdialysateTemperature" QT_MOC_LITERAL(74, 1844, 33), // "dialysateTemperatureActualCha..." QT_MOC_LITERAL(75, 1878, 27), // "vdialysateTemperatureActual" QT_MOC_LITERAL(76, 1906, 26), // "dialysateVolumeUsedChanged" QT_MOC_LITERAL(77, 1933, 20), // "vdialysateVolumeUsed" QT_MOC_LITERAL(78, 1954, 25), // "heparinBolusVolumeChanged" QT_MOC_LITERAL(79, 1980, 19), // "vheparinBolusVolume" QT_MOC_LITERAL(80, 2000, 31), // "heparinBolusVolumeActualChanged" QT_MOC_LITERAL(81, 2032, 25), // "vheparinBolusVolumeActual" QT_MOC_LITERAL(82, 2058, 26), // "heparinDispenseRateChanged" QT_MOC_LITERAL(83, 2085, 20), // "vheparinDispenseRate" QT_MOC_LITERAL(84, 2106, 32), // "heparinDispenseRateActualChanged" QT_MOC_LITERAL(85, 2139, 26), // "vheparinDispenseRateActual" QT_MOC_LITERAL(86, 2166, 29), // "heparinDeliveredVolumeChanged" QT_MOC_LITERAL(87, 2196, 23), // "vheparinDeliveredVolume" QT_MOC_LITERAL(88, 2220, 15), // "uFVolumeChanged" QT_MOC_LITERAL(89, 2236, 9), // "vuFVolume" QT_MOC_LITERAL(90, 2246, 21), // "uFVolumeActualChanged" QT_MOC_LITERAL(91, 2268, 15), // "vuFVolumeActual" QT_MOC_LITERAL(92, 2284, 21), // "uFVolumeTargetChanged" QT_MOC_LITERAL(93, 2306, 15), // "vuFVolumeTarget" QT_MOC_LITERAL(94, 2322, 13), // "uFRateChanged" QT_MOC_LITERAL(95, 2336, 7), // "vuFRate" QT_MOC_LITERAL(96, 2344, 19), // "uFRateActualChanged" QT_MOC_LITERAL(97, 2364, 13), // "vuFRateActual" QT_MOC_LITERAL(98, 2378, 19), // "uFRateTargetChanged" QT_MOC_LITERAL(99, 2398, 13), // "vuFRateTarget" QT_MOC_LITERAL(100, 2412, 25), // "substitutionVolumeChanged" QT_MOC_LITERAL(101, 2438, 19), // "vsubstitutionVolume" QT_MOC_LITERAL(102, 2458, 31), // "substitutionVolumeActualChanged" QT_MOC_LITERAL(103, 2490, 25), // "vsubstitutionVolumeActual" QT_MOC_LITERAL(104, 2516, 31), // "substitutionVolumeTargetChanged" QT_MOC_LITERAL(105, 2548, 25), // "vsubstitutionVolumeTarget" QT_MOC_LITERAL(106, 2574, 23), // "substitutionRateChanged" QT_MOC_LITERAL(107, 2598, 17), // "vsubstitutionRate" QT_MOC_LITERAL(108, 2616, 29), // "substitutionRateActualChanged" QT_MOC_LITERAL(109, 2646, 23), // "vsubstitutionRateActual" QT_MOC_LITERAL(110, 2670, 29), // "substitutionRateTargetChanged" QT_MOC_LITERAL(111, 2700, 23), // "vsubstitutionRateTarget" QT_MOC_LITERAL(112, 2724, 18), // "isoUfVolumeChanged" QT_MOC_LITERAL(113, 2743, 12), // "visoUfVolume" QT_MOC_LITERAL(114, 2756, 24), // "isoUfVolumeActualChanged" QT_MOC_LITERAL(115, 2781, 18), // "visoUfVolumeActual" QT_MOC_LITERAL(116, 2800, 24), // "isoUfVolumeTargetChanged" QT_MOC_LITERAL(117, 2825, 18), // "visoUfVolumeTarget" QT_MOC_LITERAL(118, 2844, 16), // "isoUfRateChanged" QT_MOC_LITERAL(119, 2861, 10), // "visoUfRate" QT_MOC_LITERAL(120, 2872, 22), // "isoUfRateActualChanged" QT_MOC_LITERAL(121, 2895, 16), // "visoUfRateActual" QT_MOC_LITERAL(122, 2912, 22), // "isoUfRateTargetChanged" QT_MOC_LITERAL(123, 2935, 16), // "visoUfRateTarget" QT_MOC_LITERAL(124, 2952, 28), // "waterSampleTestResultChanged" QT_MOC_LITERAL(125, 2981, 22), // "vwaterSampleTestResult" QT_MOC_LITERAL(126, 3004, 13), // "txCodeChanged" QT_MOC_LITERAL(127, 3018, 7), // "vtxCode" QT_MOC_LITERAL(128, 3026, 19), // "notificationChanged" QT_MOC_LITERAL(129, 3046, 13), // "vnotification" QT_MOC_LITERAL(130, 3060, 13), // "didAdjustment" QT_MOC_LITERAL(131, 3074, 29), // "AdjustTreatmentLogRequestData" QT_MOC_LITERAL(132, 3104, 5), // "vData" QT_MOC_LITERAL(133, 3110, 15), // "onActionReceive" QT_MOC_LITERAL(134, 3126, 30), // "AdjustTreatmentLogResponseData" QT_MOC_LITERAL(135, 3157, 21), // "TreatmentLogAvrgeData" QT_MOC_LITERAL(136, 3179, 21), // "TreatmentLogAlarmData" QT_MOC_LITERAL(137, 3201, 21), // "TreatmentLogEventData" QT_MOC_LITERAL(138, 3223, 9), // "doRequest" QT_MOC_LITERAL(139, 3233, 10), // "adjustment" QT_MOC_LITERAL(140, 3244, 9), // "patientID" QT_MOC_LITERAL(141, 3254, 13), // "bloodFlowRate" QT_MOC_LITERAL(142, 3268, 19), // "bloodFlowRateActual" QT_MOC_LITERAL(143, 3288, 17), // "dialysateFlowRate" QT_MOC_LITERAL(144, 3306, 23), // "dialysateFlowRateActual" QT_MOC_LITERAL(145, 3330, 17), // "treatmentDuration" QT_MOC_LITERAL(146, 3348, 23), // "treatmentDurationActual" QT_MOC_LITERAL(147, 3372, 19), // "acidConcentrateType" QT_MOC_LITERAL(148, 3392, 25), // "acidConcentrateTypeActual" QT_MOC_LITERAL(149, 3418, 24), // "bicarbonateCartridgeSize" QT_MOC_LITERAL(150, 3443, 30), // "bicarbonateCartridgeSizeActual" QT_MOC_LITERAL(151, 3474, 22), // "potassiumConcentration" QT_MOC_LITERAL(152, 3497, 28), // "potassiumConcentrationActual" QT_MOC_LITERAL(153, 3526, 20), // "calciumConcentration" QT_MOC_LITERAL(154, 3547, 26), // "calciumConcentrationActual" QT_MOC_LITERAL(155, 3574, 24), // "bicarbonateConcentration" QT_MOC_LITERAL(156, 3599, 30), // "bicarbonateConcentrationActual" QT_MOC_LITERAL(157, 3630, 19), // "sodiumConcentration" QT_MOC_LITERAL(158, 3650, 25), // "sodiumConcentrationActual" QT_MOC_LITERAL(159, 3676, 14), // "vitalsInterval" QT_MOC_LITERAL(160, 3691, 20), // "vitalsIntervalActual" QT_MOC_LITERAL(161, 3712, 12), // "dialyzerType" QT_MOC_LITERAL(162, 3725, 19), // "treatmentStartEpoch" QT_MOC_LITERAL(163, 3745, 17), // "treatmentEndEpoch" QT_MOC_LITERAL(164, 3763, 16), // "fluidBolusVolume" QT_MOC_LITERAL(165, 3780, 22), // "fluidBolusVolumeActual" QT_MOC_LITERAL(166, 3803, 11), // "heparinType" QT_MOC_LITERAL(167, 3815, 23), // "heparinDeliveryDuration" QT_MOC_LITERAL(168, 3839, 29), // "heparinDeliveryDurationActual" QT_MOC_LITERAL(169, 3869, 17), // "treatmentModality" QT_MOC_LITERAL(170, 3887, 23), // "treatmentModalityActual" QT_MOC_LITERAL(171, 3911, 16), // "hDFOperatingMode" QT_MOC_LITERAL(172, 3928, 22), // "hDFOperatingModeActual" QT_MOC_LITERAL(173, 3951, 15), // "hepatitisStatus" QT_MOC_LITERAL(174, 3967, 20), // "dialysateTemperature" QT_MOC_LITERAL(175, 3988, 26), // "dialysateTemperatureActual" QT_MOC_LITERAL(176, 4015, 19), // "dialysateVolumeUsed" QT_MOC_LITERAL(177, 4035, 18), // "heparinBolusVolume" QT_MOC_LITERAL(178, 4054, 24), // "heparinBolusVolumeActual" QT_MOC_LITERAL(179, 4079, 19), // "heparinDispenseRate" QT_MOC_LITERAL(180, 4099, 25), // "heparinDispenseRateActual" QT_MOC_LITERAL(181, 4125, 22), // "heparinDeliveredVolume" QT_MOC_LITERAL(182, 4148, 8), // "uFVolume" QT_MOC_LITERAL(183, 4157, 14), // "uFVolumeActual" QT_MOC_LITERAL(184, 4172, 14), // "uFVolumeTarget" QT_MOC_LITERAL(185, 4187, 6), // "uFRate" QT_MOC_LITERAL(186, 4194, 12), // "uFRateActual" QT_MOC_LITERAL(187, 4207, 12), // "uFRateTarget" QT_MOC_LITERAL(188, 4220, 18), // "substitutionVolume" QT_MOC_LITERAL(189, 4239, 24), // "substitutionVolumeActual" QT_MOC_LITERAL(190, 4264, 24), // "substitutionVolumeTarget" QT_MOC_LITERAL(191, 4289, 16), // "substitutionRate" QT_MOC_LITERAL(192, 4306, 22), // "substitutionRateActual" QT_MOC_LITERAL(193, 4329, 22), // "substitutionRateTarget" QT_MOC_LITERAL(194, 4352, 11), // "isoUfVolume" QT_MOC_LITERAL(195, 4364, 17), // "isoUfVolumeActual" QT_MOC_LITERAL(196, 4382, 17), // "isoUfVolumeTarget" QT_MOC_LITERAL(197, 4400, 9), // "isoUfRate" QT_MOC_LITERAL(198, 4410, 15), // "isoUfRateActual" QT_MOC_LITERAL(199, 4426, 15), // "isoUfRateTarget" QT_MOC_LITERAL(200, 4442, 21), // "waterSampleTestResult" QT_MOC_LITERAL(201, 4464, 6), // "txCode" QT_MOC_LITERAL(202, 4471, 12) // "notification" }, "View::VPostTreatmentAdjustmentTreatmentLog\0" "adjustmentTriggered\0\0vadjustment\0" "patientIDChanged\0vpatientID\0" "bloodFlowRateChanged\0vbloodFlowRate\0" "bloodFlowRateActualChanged\0" "vbloodFlowRateActual\0dialysateFlowRateChanged\0" "vdialysateFlowRate\0dialysateFlowRateActualChanged\0" "vdialysateFlowRateActual\0" "treatmentDurationChanged\0vtreatmentDuration\0" "treatmentDurationActualChanged\0" "vtreatmentDurationActual\0" "acidConcentrateTypeChanged\0" "vacidConcentrateType\0" "acidConcentrateTypeActualChanged\0" "vacidConcentrateTypeActual\0" "bicarbonateCartridgeSizeChanged\0" "vbicarbonateCartridgeSize\0" "bicarbonateCartridgeSizeActualChanged\0" "vbicarbonateCartridgeSizeActual\0" "potassiumConcentrationChanged\0" "vpotassiumConcentration\0" "potassiumConcentrationActualChanged\0" "vpotassiumConcentrationActual\0" "calciumConcentrationChanged\0" "vcalciumConcentration\0" "calciumConcentrationActualChanged\0" "vcalciumConcentrationActual\0" "bicarbonateConcentrationChanged\0" "vbicarbonateConcentration\0" "bicarbonateConcentrationActualChanged\0" "vbicarbonateConcentrationActual\0" "sodiumConcentrationChanged\0" "vsodiumConcentration\0" "sodiumConcentrationActualChanged\0" "vsodiumConcentrationActual\0" "vitalsIntervalChanged\0vvitalsInterval\0" "vitalsIntervalActualChanged\0" "vvitalsIntervalActual\0dialyzerTypeChanged\0" "vdialyzerType\0treatmentStartEpochChanged\0" "vtreatmentStartEpoch\0treatmentEndEpochChanged\0" "vtreatmentEndEpoch\0fluidBolusVolumeChanged\0" "vfluidBolusVolume\0fluidBolusVolumeActualChanged\0" "vfluidBolusVolumeActual\0heparinTypeChanged\0" "vheparinType\0heparinDeliveryDurationChanged\0" "vheparinDeliveryDuration\0" "heparinDeliveryDurationActualChanged\0" "vheparinDeliveryDurationActual\0" "treatmentModalityChanged\0vtreatmentModality\0" "treatmentModalityActualChanged\0" "vtreatmentModalityActual\0" "hDFOperatingModeChanged\0vhDFOperatingMode\0" "hDFOperatingModeActualChanged\0" "vhDFOperatingModeActual\0hepatitisStatusChanged\0" "vhepatitisStatus\0dialysateTemperatureChanged\0" "vdialysateTemperature\0" "dialysateTemperatureActualChanged\0" "vdialysateTemperatureActual\0" "dialysateVolumeUsedChanged\0" "vdialysateVolumeUsed\0heparinBolusVolumeChanged\0" "vheparinBolusVolume\0heparinBolusVolumeActualChanged\0" "vheparinBolusVolumeActual\0" "heparinDispenseRateChanged\0" "vheparinDispenseRate\0" "heparinDispenseRateActualChanged\0" "vheparinDispenseRateActual\0" "heparinDeliveredVolumeChanged\0" "vheparinDeliveredVolume\0uFVolumeChanged\0" "vuFVolume\0uFVolumeActualChanged\0" "vuFVolumeActual\0uFVolumeTargetChanged\0" "vuFVolumeTarget\0uFRateChanged\0vuFRate\0" "uFRateActualChanged\0vuFRateActual\0" "uFRateTargetChanged\0vuFRateTarget\0" "substitutionVolumeChanged\0vsubstitutionVolume\0" "substitutionVolumeActualChanged\0" "vsubstitutionVolumeActual\0" "substitutionVolumeTargetChanged\0" "vsubstitutionVolumeTarget\0" "substitutionRateChanged\0vsubstitutionRate\0" "substitutionRateActualChanged\0" "vsubstitutionRateActual\0" "substitutionRateTargetChanged\0" "vsubstitutionRateTarget\0isoUfVolumeChanged\0" "visoUfVolume\0isoUfVolumeActualChanged\0" "visoUfVolumeActual\0isoUfVolumeTargetChanged\0" "visoUfVolumeTarget\0isoUfRateChanged\0" "visoUfRate\0isoUfRateActualChanged\0" "visoUfRateActual\0isoUfRateTargetChanged\0" "visoUfRateTarget\0waterSampleTestResultChanged\0" "vwaterSampleTestResult\0txCodeChanged\0" "vtxCode\0notificationChanged\0vnotification\0" "didAdjustment\0AdjustTreatmentLogRequestData\0" "vData\0onActionReceive\0" "AdjustTreatmentLogResponseData\0" "TreatmentLogAvrgeData\0TreatmentLogAlarmData\0" "TreatmentLogEventData\0doRequest\0" "adjustment\0patientID\0bloodFlowRate\0" "bloodFlowRateActual\0dialysateFlowRate\0" "dialysateFlowRateActual\0treatmentDuration\0" "treatmentDurationActual\0acidConcentrateType\0" "acidConcentrateTypeActual\0" "bicarbonateCartridgeSize\0" "bicarbonateCartridgeSizeActual\0" "potassiumConcentration\0" "potassiumConcentrationActual\0" "calciumConcentration\0calciumConcentrationActual\0" "bicarbonateConcentration\0" "bicarbonateConcentrationActual\0" "sodiumConcentration\0sodiumConcentrationActual\0" "vitalsInterval\0vitalsIntervalActual\0" "dialyzerType\0treatmentStartEpoch\0" "treatmentEndEpoch\0fluidBolusVolume\0" "fluidBolusVolumeActual\0heparinType\0" "heparinDeliveryDuration\0" "heparinDeliveryDurationActual\0" "treatmentModality\0treatmentModalityActual\0" "hDFOperatingMode\0hDFOperatingModeActual\0" "hepatitisStatus\0dialysateTemperature\0" "dialysateTemperatureActual\0" "dialysateVolumeUsed\0heparinBolusVolume\0" "heparinBolusVolumeActual\0heparinDispenseRate\0" "heparinDispenseRateActual\0" "heparinDeliveredVolume\0uFVolume\0" "uFVolumeActual\0uFVolumeTarget\0uFRate\0" "uFRateActual\0uFRateTarget\0substitutionVolume\0" "substitutionVolumeActual\0" "substitutionVolumeTarget\0substitutionRate\0" "substitutionRateActual\0substitutionRateTarget\0" "isoUfVolume\0isoUfVolumeActual\0" "isoUfVolumeTarget\0isoUfRate\0isoUfRateActual\0" "isoUfRateTarget\0waterSampleTestResult\0" "txCode\0notification" }; #undef QT_MOC_LITERAL static const uint qt_meta_data_View__VPostTreatmentAdjustmentTreatmentLog[] = { // content: 8, // revision 0, // classname 0, 0, // classinfo 70, 14, // methods 64, 572, // properties 0, 0, // enums/sets 0, 0, // constructors 0, // flags 65, // signalCount // signals: name, argc, parameters, tag, flags 1, 1, 364, 2, 0x06 /* Public */, 4, 1, 367, 2, 0x06 /* Public */, 6, 1, 370, 2, 0x06 /* Public */, 8, 1, 373, 2, 0x06 /* Public */, 10, 1, 376, 2, 0x06 /* Public */, 12, 1, 379, 2, 0x06 /* Public */, 14, 1, 382, 2, 0x06 /* Public */, 16, 1, 385, 2, 0x06 /* Public */, 18, 1, 388, 2, 0x06 /* Public */, 20, 1, 391, 2, 0x06 /* Public */, 22, 1, 394, 2, 0x06 /* Public */, 24, 1, 397, 2, 0x06 /* Public */, 26, 1, 400, 2, 0x06 /* Public */, 28, 1, 403, 2, 0x06 /* Public */, 30, 1, 406, 2, 0x06 /* Public */, 32, 1, 409, 2, 0x06 /* Public */, 34, 1, 412, 2, 0x06 /* Public */, 36, 1, 415, 2, 0x06 /* Public */, 38, 1, 418, 2, 0x06 /* Public */, 40, 1, 421, 2, 0x06 /* Public */, 42, 1, 424, 2, 0x06 /* Public */, 44, 1, 427, 2, 0x06 /* Public */, 46, 1, 430, 2, 0x06 /* Public */, 48, 1, 433, 2, 0x06 /* Public */, 50, 1, 436, 2, 0x06 /* Public */, 52, 1, 439, 2, 0x06 /* Public */, 54, 1, 442, 2, 0x06 /* Public */, 56, 1, 445, 2, 0x06 /* Public */, 58, 1, 448, 2, 0x06 /* Public */, 60, 1, 451, 2, 0x06 /* Public */, 62, 1, 454, 2, 0x06 /* Public */, 64, 1, 457, 2, 0x06 /* Public */, 66, 1, 460, 2, 0x06 /* Public */, 68, 1, 463, 2, 0x06 /* Public */, 70, 1, 466, 2, 0x06 /* Public */, 72, 1, 469, 2, 0x06 /* Public */, 74, 1, 472, 2, 0x06 /* Public */, 76, 1, 475, 2, 0x06 /* Public */, 78, 1, 478, 2, 0x06 /* Public */, 80, 1, 481, 2, 0x06 /* Public */, 82, 1, 484, 2, 0x06 /* Public */, 84, 1, 487, 2, 0x06 /* Public */, 86, 1, 490, 2, 0x06 /* Public */, 88, 1, 493, 2, 0x06 /* Public */, 90, 1, 496, 2, 0x06 /* Public */, 92, 1, 499, 2, 0x06 /* Public */, 94, 1, 502, 2, 0x06 /* Public */, 96, 1, 505, 2, 0x06 /* Public */, 98, 1, 508, 2, 0x06 /* Public */, 100, 1, 511, 2, 0x06 /* Public */, 102, 1, 514, 2, 0x06 /* Public */, 104, 1, 517, 2, 0x06 /* Public */, 106, 1, 520, 2, 0x06 /* Public */, 108, 1, 523, 2, 0x06 /* Public */, 110, 1, 526, 2, 0x06 /* Public */, 112, 1, 529, 2, 0x06 /* Public */, 114, 1, 532, 2, 0x06 /* Public */, 116, 1, 535, 2, 0x06 /* Public */, 118, 1, 538, 2, 0x06 /* Public */, 120, 1, 541, 2, 0x06 /* Public */, 122, 1, 544, 2, 0x06 /* Public */, 124, 1, 547, 2, 0x06 /* Public */, 126, 1, 550, 2, 0x06 /* Public */, 128, 1, 553, 2, 0x06 /* Public */, 130, 1, 556, 2, 0x06 /* Public */, // slots: name, argc, parameters, tag, flags 133, 1, 559, 2, 0x08 /* Private */, 133, 1, 562, 2, 0x08 /* Private */, 133, 1, 565, 2, 0x08 /* Private */, 133, 1, 568, 2, 0x08 /* Private */, 138, 0, 571, 2, 0x0a /* Public */, // signals: parameters QMetaType::Void, QMetaType::Bool, 3, QMetaType::Void, QMetaType::QString, 5, QMetaType::Void, QMetaType::UInt, 7, QMetaType::Void, QMetaType::UInt, 9, QMetaType::Void, QMetaType::UInt, 11, QMetaType::Void, QMetaType::UInt, 13, QMetaType::Void, QMetaType::UInt, 15, QMetaType::Void, QMetaType::UInt, 17, QMetaType::Void, QMetaType::UInt, 19, QMetaType::Void, QMetaType::UInt, 21, QMetaType::Void, QMetaType::UInt, 23, QMetaType::Void, QMetaType::UInt, 25, QMetaType::Void, QMetaType::UInt, 27, QMetaType::Void, QMetaType::UInt, 29, QMetaType::Void, QMetaType::UInt, 31, QMetaType::Void, QMetaType::UInt, 33, QMetaType::Void, QMetaType::UInt, 35, QMetaType::Void, QMetaType::UInt, 37, QMetaType::Void, QMetaType::UInt, 39, QMetaType::Void, QMetaType::UInt, 41, QMetaType::Void, QMetaType::UInt, 43, QMetaType::Void, QMetaType::UInt, 45, QMetaType::Void, QMetaType::UInt, 47, QMetaType::Void, QMetaType::QString, 49, QMetaType::Void, QMetaType::QString, 51, QMetaType::Void, QMetaType::UInt, 53, QMetaType::Void, QMetaType::UInt, 55, QMetaType::Void, QMetaType::UInt, 57, QMetaType::Void, QMetaType::UInt, 59, QMetaType::Void, QMetaType::UInt, 61, QMetaType::Void, QMetaType::UInt, 63, QMetaType::Void, QMetaType::UInt, 65, QMetaType::Void, QMetaType::UInt, 67, QMetaType::Void, QMetaType::UInt, 69, QMetaType::Void, QMetaType::UInt, 71, QMetaType::Void, QMetaType::Float, 73, QMetaType::Void, QMetaType::Float, 75, QMetaType::Void, QMetaType::Float, 77, QMetaType::Void, QMetaType::Float, 79, QMetaType::Void, QMetaType::Float, 81, QMetaType::Void, QMetaType::Float, 83, QMetaType::Void, QMetaType::Float, 85, QMetaType::Void, QMetaType::Float, 87, QMetaType::Void, QMetaType::Float, 89, QMetaType::Void, QMetaType::Float, 91, QMetaType::Void, QMetaType::Float, 93, QMetaType::Void, QMetaType::Float, 95, QMetaType::Void, QMetaType::Float, 97, QMetaType::Void, QMetaType::Float, 99, QMetaType::Void, QMetaType::Float, 101, QMetaType::Void, QMetaType::Float, 103, QMetaType::Void, QMetaType::Float, 105, QMetaType::Void, QMetaType::Float, 107, QMetaType::Void, QMetaType::Float, 109, QMetaType::Void, QMetaType::Float, 111, QMetaType::Void, QMetaType::Float, 113, QMetaType::Void, QMetaType::Float, 115, QMetaType::Void, QMetaType::Float, 117, QMetaType::Void, QMetaType::Float, 119, QMetaType::Void, QMetaType::Float, 121, QMetaType::Void, QMetaType::Float, 123, QMetaType::Void, QMetaType::Float, 125, QMetaType::Void, QMetaType::QString, 127, QMetaType::Void, QMetaType::QString, 129, QMetaType::Void, 0x80000000 | 131, 132, // slots: parameters QMetaType::Void, 0x80000000 | 134, 132, QMetaType::Void, 0x80000000 | 135, 132, QMetaType::Void, 0x80000000 | 136, 132, QMetaType::Void, 0x80000000 | 137, 132, QMetaType::Void, // properties: name, type, flags 139, QMetaType::Bool, 0x00495003, 140, QMetaType::QString, 0x00495003, 141, QMetaType::UInt, 0x00495003, 142, QMetaType::UInt, 0x00495003, 143, QMetaType::UInt, 0x00495003, 144, QMetaType::UInt, 0x00495003, 145, QMetaType::UInt, 0x00495003, 146, QMetaType::UInt, 0x00495003, 147, QMetaType::UInt, 0x00495003, 148, QMetaType::UInt, 0x00495003, 149, QMetaType::UInt, 0x00495003, 150, QMetaType::UInt, 0x00495003, 151, QMetaType::UInt, 0x00495003, 152, QMetaType::UInt, 0x00495003, 153, QMetaType::UInt, 0x00495003, 154, QMetaType::UInt, 0x00495003, 155, QMetaType::UInt, 0x00495003, 156, QMetaType::UInt, 0x00495003, 157, QMetaType::UInt, 0x00495003, 158, QMetaType::UInt, 0x00495003, 159, QMetaType::UInt, 0x00495003, 160, QMetaType::UInt, 0x00495003, 161, QMetaType::UInt, 0x00495003, 162, QMetaType::QString, 0x00495003, 163, QMetaType::QString, 0x00495003, 164, QMetaType::UInt, 0x00495003, 165, QMetaType::UInt, 0x00495003, 166, QMetaType::UInt, 0x00495003, 167, QMetaType::UInt, 0x00495003, 168, QMetaType::UInt, 0x00495003, 169, QMetaType::UInt, 0x00495003, 170, QMetaType::UInt, 0x00495003, 171, QMetaType::UInt, 0x00495003, 172, QMetaType::UInt, 0x00495003, 173, QMetaType::UInt, 0x00495003, 174, QMetaType::Float, 0x00495003, 175, QMetaType::Float, 0x00495003, 176, QMetaType::Float, 0x00495003, 177, QMetaType::Float, 0x00495003, 178, QMetaType::Float, 0x00495003, 179, QMetaType::Float, 0x00495003, 180, QMetaType::Float, 0x00495003, 181, QMetaType::Float, 0x00495003, 182, QMetaType::Float, 0x00495003, 183, QMetaType::Float, 0x00495003, 184, QMetaType::Float, 0x00495003, 185, QMetaType::Float, 0x00495003, 186, QMetaType::Float, 0x00495003, 187, QMetaType::Float, 0x00495003, 188, QMetaType::Float, 0x00495003, 189, QMetaType::Float, 0x00495003, 190, QMetaType::Float, 0x00495003, 191, QMetaType::Float, 0x00495003, 192, QMetaType::Float, 0x00495003, 193, QMetaType::Float, 0x00495003, 194, QMetaType::Float, 0x00495003, 195, QMetaType::Float, 0x00495003, 196, QMetaType::Float, 0x00495003, 197, QMetaType::Float, 0x00495003, 198, QMetaType::Float, 0x00495003, 199, QMetaType::Float, 0x00495003, 200, QMetaType::Float, 0x00495003, 201, QMetaType::QString, 0x00495003, 202, QMetaType::QString, 0x00495003, // properties: notify_signal_id 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 0 // eod }; void View::VPostTreatmentAdjustmentTreatmentLog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a) { if (_c == QMetaObject::InvokeMetaMethod) { auto *_t = static_cast(_o); (void)_t; switch (_id) { case 0: _t->adjustmentTriggered((*reinterpret_cast< const bool(*)>(_a[1]))); break; case 1: _t->patientIDChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break; case 2: _t->bloodFlowRateChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 3: _t->bloodFlowRateActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 4: _t->dialysateFlowRateChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 5: _t->dialysateFlowRateActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 6: _t->treatmentDurationChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 7: _t->treatmentDurationActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 8: _t->acidConcentrateTypeChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 9: _t->acidConcentrateTypeActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 10: _t->bicarbonateCartridgeSizeChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 11: _t->bicarbonateCartridgeSizeActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 12: _t->potassiumConcentrationChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 13: _t->potassiumConcentrationActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 14: _t->calciumConcentrationChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 15: _t->calciumConcentrationActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 16: _t->bicarbonateConcentrationChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 17: _t->bicarbonateConcentrationActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 18: _t->sodiumConcentrationChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 19: _t->sodiumConcentrationActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 20: _t->vitalsIntervalChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 21: _t->vitalsIntervalActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 22: _t->dialyzerTypeChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 23: _t->treatmentStartEpochChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break; case 24: _t->treatmentEndEpochChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break; case 25: _t->fluidBolusVolumeChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 26: _t->fluidBolusVolumeActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 27: _t->heparinTypeChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 28: _t->heparinDeliveryDurationChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 29: _t->heparinDeliveryDurationActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 30: _t->treatmentModalityChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 31: _t->treatmentModalityActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 32: _t->hDFOperatingModeChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 33: _t->hDFOperatingModeActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 34: _t->hepatitisStatusChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; case 35: _t->dialysateTemperatureChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 36: _t->dialysateTemperatureActualChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 37: _t->dialysateVolumeUsedChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 38: _t->heparinBolusVolumeChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 39: _t->heparinBolusVolumeActualChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 40: _t->heparinDispenseRateChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 41: _t->heparinDispenseRateActualChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 42: _t->heparinDeliveredVolumeChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 43: _t->uFVolumeChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 44: _t->uFVolumeActualChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 45: _t->uFVolumeTargetChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 46: _t->uFRateChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 47: _t->uFRateActualChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 48: _t->uFRateTargetChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 49: _t->substitutionVolumeChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 50: _t->substitutionVolumeActualChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 51: _t->substitutionVolumeTargetChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 52: _t->substitutionRateChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 53: _t->substitutionRateActualChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 54: _t->substitutionRateTargetChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 55: _t->isoUfVolumeChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 56: _t->isoUfVolumeActualChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 57: _t->isoUfVolumeTargetChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 58: _t->isoUfRateChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 59: _t->isoUfRateActualChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 60: _t->isoUfRateTargetChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 61: _t->waterSampleTestResultChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; case 62: _t->txCodeChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break; case 63: _t->notificationChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break; case 64: _t->didAdjustment((*reinterpret_cast< const AdjustTreatmentLogRequestData(*)>(_a[1]))); break; case 65: _t->onActionReceive((*reinterpret_cast< const AdjustTreatmentLogResponseData(*)>(_a[1]))); break; case 66: _t->onActionReceive((*reinterpret_cast< const TreatmentLogAvrgeData(*)>(_a[1]))); break; case 67: _t->onActionReceive((*reinterpret_cast< const TreatmentLogAlarmData(*)>(_a[1]))); break; case 68: _t->onActionReceive((*reinterpret_cast< const TreatmentLogEventData(*)>(_a[1]))); break; case 69: _t->doRequest(); break; default: ; } } else if (_c == QMetaObject::IndexOfMethod) { int *result = reinterpret_cast(_a[0]); { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const bool & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::adjustmentTriggered)) { *result = 0; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const QString & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::patientIDChanged)) { *result = 1; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::bloodFlowRateChanged)) { *result = 2; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::bloodFlowRateActualChanged)) { *result = 3; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::dialysateFlowRateChanged)) { *result = 4; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::dialysateFlowRateActualChanged)) { *result = 5; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::treatmentDurationChanged)) { *result = 6; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::treatmentDurationActualChanged)) { *result = 7; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::acidConcentrateTypeChanged)) { *result = 8; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::acidConcentrateTypeActualChanged)) { *result = 9; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::bicarbonateCartridgeSizeChanged)) { *result = 10; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::bicarbonateCartridgeSizeActualChanged)) { *result = 11; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::potassiumConcentrationChanged)) { *result = 12; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::potassiumConcentrationActualChanged)) { *result = 13; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::calciumConcentrationChanged)) { *result = 14; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::calciumConcentrationActualChanged)) { *result = 15; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::bicarbonateConcentrationChanged)) { *result = 16; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::bicarbonateConcentrationActualChanged)) { *result = 17; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::sodiumConcentrationChanged)) { *result = 18; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::sodiumConcentrationActualChanged)) { *result = 19; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::vitalsIntervalChanged)) { *result = 20; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::vitalsIntervalActualChanged)) { *result = 21; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::dialyzerTypeChanged)) { *result = 22; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const QString & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::treatmentStartEpochChanged)) { *result = 23; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const QString & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::treatmentEndEpochChanged)) { *result = 24; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::fluidBolusVolumeChanged)) { *result = 25; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::fluidBolusVolumeActualChanged)) { *result = 26; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::heparinTypeChanged)) { *result = 27; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::heparinDeliveryDurationChanged)) { *result = 28; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::heparinDeliveryDurationActualChanged)) { *result = 29; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::treatmentModalityChanged)) { *result = 30; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::treatmentModalityActualChanged)) { *result = 31; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::hDFOperatingModeChanged)) { *result = 32; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::hDFOperatingModeActualChanged)) { *result = 33; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::hepatitisStatusChanged)) { *result = 34; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::dialysateTemperatureChanged)) { *result = 35; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::dialysateTemperatureActualChanged)) { *result = 36; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::dialysateVolumeUsedChanged)) { *result = 37; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::heparinBolusVolumeChanged)) { *result = 38; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::heparinBolusVolumeActualChanged)) { *result = 39; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::heparinDispenseRateChanged)) { *result = 40; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::heparinDispenseRateActualChanged)) { *result = 41; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::heparinDeliveredVolumeChanged)) { *result = 42; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::uFVolumeChanged)) { *result = 43; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::uFVolumeActualChanged)) { *result = 44; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::uFVolumeTargetChanged)) { *result = 45; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::uFRateChanged)) { *result = 46; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::uFRateActualChanged)) { *result = 47; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::uFRateTargetChanged)) { *result = 48; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::substitutionVolumeChanged)) { *result = 49; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::substitutionVolumeActualChanged)) { *result = 50; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::substitutionVolumeTargetChanged)) { *result = 51; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::substitutionRateChanged)) { *result = 52; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::substitutionRateActualChanged)) { *result = 53; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::substitutionRateTargetChanged)) { *result = 54; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::isoUfVolumeChanged)) { *result = 55; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::isoUfVolumeActualChanged)) { *result = 56; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::isoUfVolumeTargetChanged)) { *result = 57; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::isoUfRateChanged)) { *result = 58; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::isoUfRateActualChanged)) { *result = 59; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::isoUfRateTargetChanged)) { *result = 60; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::waterSampleTestResultChanged)) { *result = 61; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const QString & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::txCodeChanged)) { *result = 62; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const QString & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::notificationChanged)) { *result = 63; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const AdjustTreatmentLogRequestData & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::didAdjustment)) { *result = 64; return; } } } #ifndef QT_NO_PROPERTIES else if (_c == QMetaObject::ReadProperty) { auto *_t = static_cast(_o); (void)_t; void *_v = _a[0]; switch (_id) { case 0: *reinterpret_cast< bool*>(_v) = _t->adjustment(); break; case 1: *reinterpret_cast< QString*>(_v) = _t->patientID(); break; case 2: *reinterpret_cast< quint32*>(_v) = _t->bloodFlowRate(); break; case 3: *reinterpret_cast< quint32*>(_v) = _t->bloodFlowRateActual(); break; case 4: *reinterpret_cast< quint32*>(_v) = _t->dialysateFlowRate(); break; case 5: *reinterpret_cast< quint32*>(_v) = _t->dialysateFlowRateActual(); break; case 6: *reinterpret_cast< quint32*>(_v) = _t->treatmentDuration(); break; case 7: *reinterpret_cast< quint32*>(_v) = _t->treatmentDurationActual(); break; case 8: *reinterpret_cast< quint32*>(_v) = _t->acidConcentrateType(); break; case 9: *reinterpret_cast< quint32*>(_v) = _t->acidConcentrateTypeActual(); break; case 10: *reinterpret_cast< quint32*>(_v) = _t->bicarbonateCartridgeSize(); break; case 11: *reinterpret_cast< quint32*>(_v) = _t->bicarbonateCartridgeSizeActual(); break; case 12: *reinterpret_cast< quint32*>(_v) = _t->potassiumConcentration(); break; case 13: *reinterpret_cast< quint32*>(_v) = _t->potassiumConcentrationActual(); break; case 14: *reinterpret_cast< quint32*>(_v) = _t->calciumConcentration(); break; case 15: *reinterpret_cast< quint32*>(_v) = _t->calciumConcentrationActual(); break; case 16: *reinterpret_cast< quint32*>(_v) = _t->bicarbonateConcentration(); break; case 17: *reinterpret_cast< quint32*>(_v) = _t->bicarbonateConcentrationActual(); break; case 18: *reinterpret_cast< quint32*>(_v) = _t->sodiumConcentration(); break; case 19: *reinterpret_cast< quint32*>(_v) = _t->sodiumConcentrationActual(); break; case 20: *reinterpret_cast< quint32*>(_v) = _t->vitalsInterval(); break; case 21: *reinterpret_cast< quint32*>(_v) = _t->vitalsIntervalActual(); break; case 22: *reinterpret_cast< quint32*>(_v) = _t->dialyzerType(); break; case 23: *reinterpret_cast< QString*>(_v) = _t->treatmentStartEpoch(); break; case 24: *reinterpret_cast< QString*>(_v) = _t->treatmentEndEpoch(); break; case 25: *reinterpret_cast< quint32*>(_v) = _t->fluidBolusVolume(); break; case 26: *reinterpret_cast< quint32*>(_v) = _t->fluidBolusVolumeActual(); break; case 27: *reinterpret_cast< quint32*>(_v) = _t->heparinType(); break; case 28: *reinterpret_cast< quint32*>(_v) = _t->heparinDeliveryDuration(); break; case 29: *reinterpret_cast< quint32*>(_v) = _t->heparinDeliveryDurationActual(); break; case 30: *reinterpret_cast< quint32*>(_v) = _t->treatmentModality(); break; case 31: *reinterpret_cast< quint32*>(_v) = _t->treatmentModalityActual(); break; case 32: *reinterpret_cast< quint32*>(_v) = _t->hDFOperatingMode(); break; case 33: *reinterpret_cast< quint32*>(_v) = _t->hDFOperatingModeActual(); break; case 34: *reinterpret_cast< quint32*>(_v) = _t->hepatitisStatus(); break; case 35: *reinterpret_cast< float*>(_v) = _t->dialysateTemperature(); break; case 36: *reinterpret_cast< float*>(_v) = _t->dialysateTemperatureActual(); break; case 37: *reinterpret_cast< float*>(_v) = _t->dialysateVolumeUsed(); break; case 38: *reinterpret_cast< float*>(_v) = _t->heparinBolusVolume(); break; case 39: *reinterpret_cast< float*>(_v) = _t->heparinBolusVolumeActual(); break; case 40: *reinterpret_cast< float*>(_v) = _t->heparinDispenseRate(); break; case 41: *reinterpret_cast< float*>(_v) = _t->heparinDispenseRateActual(); break; case 42: *reinterpret_cast< float*>(_v) = _t->heparinDeliveredVolume(); break; case 43: *reinterpret_cast< float*>(_v) = _t->uFVolume(); break; case 44: *reinterpret_cast< float*>(_v) = _t->uFVolumeActual(); break; case 45: *reinterpret_cast< float*>(_v) = _t->uFVolumeTarget(); break; case 46: *reinterpret_cast< float*>(_v) = _t->uFRate(); break; case 47: *reinterpret_cast< float*>(_v) = _t->uFRateActual(); break; case 48: *reinterpret_cast< float*>(_v) = _t->uFRateTarget(); break; case 49: *reinterpret_cast< float*>(_v) = _t->substitutionVolume(); break; case 50: *reinterpret_cast< float*>(_v) = _t->substitutionVolumeActual(); break; case 51: *reinterpret_cast< float*>(_v) = _t->substitutionVolumeTarget(); break; case 52: *reinterpret_cast< float*>(_v) = _t->substitutionRate(); break; case 53: *reinterpret_cast< float*>(_v) = _t->substitutionRateActual(); break; case 54: *reinterpret_cast< float*>(_v) = _t->substitutionRateTarget(); break; case 55: *reinterpret_cast< float*>(_v) = _t->isoUfVolume(); break; case 56: *reinterpret_cast< float*>(_v) = _t->isoUfVolumeActual(); break; case 57: *reinterpret_cast< float*>(_v) = _t->isoUfVolumeTarget(); break; case 58: *reinterpret_cast< float*>(_v) = _t->isoUfRate(); break; case 59: *reinterpret_cast< float*>(_v) = _t->isoUfRateActual(); break; case 60: *reinterpret_cast< float*>(_v) = _t->isoUfRateTarget(); break; case 61: *reinterpret_cast< float*>(_v) = _t->waterSampleTestResult(); break; case 62: *reinterpret_cast< QString*>(_v) = _t->txCode(); break; case 63: *reinterpret_cast< QString*>(_v) = _t->notification(); break; default: break; } } else if (_c == QMetaObject::WriteProperty) { auto *_t = static_cast(_o); (void)_t; void *_v = _a[0]; switch (_id) { case 0: _t->adjustment(*reinterpret_cast< bool*>(_v)); break; case 1: _t->patientID(*reinterpret_cast< QString*>(_v)); break; case 2: _t->bloodFlowRate(*reinterpret_cast< quint32*>(_v)); break; case 3: _t->bloodFlowRateActual(*reinterpret_cast< quint32*>(_v)); break; case 4: _t->dialysateFlowRate(*reinterpret_cast< quint32*>(_v)); break; case 5: _t->dialysateFlowRateActual(*reinterpret_cast< quint32*>(_v)); break; case 6: _t->treatmentDuration(*reinterpret_cast< quint32*>(_v)); break; case 7: _t->treatmentDurationActual(*reinterpret_cast< quint32*>(_v)); break; case 8: _t->acidConcentrateType(*reinterpret_cast< quint32*>(_v)); break; case 9: _t->acidConcentrateTypeActual(*reinterpret_cast< quint32*>(_v)); break; case 10: _t->bicarbonateCartridgeSize(*reinterpret_cast< quint32*>(_v)); break; case 11: _t->bicarbonateCartridgeSizeActual(*reinterpret_cast< quint32*>(_v)); break; case 12: _t->potassiumConcentration(*reinterpret_cast< quint32*>(_v)); break; case 13: _t->potassiumConcentrationActual(*reinterpret_cast< quint32*>(_v)); break; case 14: _t->calciumConcentration(*reinterpret_cast< quint32*>(_v)); break; case 15: _t->calciumConcentrationActual(*reinterpret_cast< quint32*>(_v)); break; case 16: _t->bicarbonateConcentration(*reinterpret_cast< quint32*>(_v)); break; case 17: _t->bicarbonateConcentrationActual(*reinterpret_cast< quint32*>(_v)); break; case 18: _t->sodiumConcentration(*reinterpret_cast< quint32*>(_v)); break; case 19: _t->sodiumConcentrationActual(*reinterpret_cast< quint32*>(_v)); break; case 20: _t->vitalsInterval(*reinterpret_cast< quint32*>(_v)); break; case 21: _t->vitalsIntervalActual(*reinterpret_cast< quint32*>(_v)); break; case 22: _t->dialyzerType(*reinterpret_cast< quint32*>(_v)); break; case 23: _t->treatmentStartEpoch(*reinterpret_cast< QString*>(_v)); break; case 24: _t->treatmentEndEpoch(*reinterpret_cast< QString*>(_v)); break; case 25: _t->fluidBolusVolume(*reinterpret_cast< quint32*>(_v)); break; case 26: _t->fluidBolusVolumeActual(*reinterpret_cast< quint32*>(_v)); break; case 27: _t->heparinType(*reinterpret_cast< quint32*>(_v)); break; case 28: _t->heparinDeliveryDuration(*reinterpret_cast< quint32*>(_v)); break; case 29: _t->heparinDeliveryDurationActual(*reinterpret_cast< quint32*>(_v)); break; case 30: _t->treatmentModality(*reinterpret_cast< quint32*>(_v)); break; case 31: _t->treatmentModalityActual(*reinterpret_cast< quint32*>(_v)); break; case 32: _t->hDFOperatingMode(*reinterpret_cast< quint32*>(_v)); break; case 33: _t->hDFOperatingModeActual(*reinterpret_cast< quint32*>(_v)); break; case 34: _t->hepatitisStatus(*reinterpret_cast< quint32*>(_v)); break; case 35: _t->dialysateTemperature(*reinterpret_cast< float*>(_v)); break; case 36: _t->dialysateTemperatureActual(*reinterpret_cast< float*>(_v)); break; case 37: _t->dialysateVolumeUsed(*reinterpret_cast< float*>(_v)); break; case 38: _t->heparinBolusVolume(*reinterpret_cast< float*>(_v)); break; case 39: _t->heparinBolusVolumeActual(*reinterpret_cast< float*>(_v)); break; case 40: _t->heparinDispenseRate(*reinterpret_cast< float*>(_v)); break; case 41: _t->heparinDispenseRateActual(*reinterpret_cast< float*>(_v)); break; case 42: _t->heparinDeliveredVolume(*reinterpret_cast< float*>(_v)); break; case 43: _t->uFVolume(*reinterpret_cast< float*>(_v)); break; case 44: _t->uFVolumeActual(*reinterpret_cast< float*>(_v)); break; case 45: _t->uFVolumeTarget(*reinterpret_cast< float*>(_v)); break; case 46: _t->uFRate(*reinterpret_cast< float*>(_v)); break; case 47: _t->uFRateActual(*reinterpret_cast< float*>(_v)); break; case 48: _t->uFRateTarget(*reinterpret_cast< float*>(_v)); break; case 49: _t->substitutionVolume(*reinterpret_cast< float*>(_v)); break; case 50: _t->substitutionVolumeActual(*reinterpret_cast< float*>(_v)); break; case 51: _t->substitutionVolumeTarget(*reinterpret_cast< float*>(_v)); break; case 52: _t->substitutionRate(*reinterpret_cast< float*>(_v)); break; case 53: _t->substitutionRateActual(*reinterpret_cast< float*>(_v)); break; case 54: _t->substitutionRateTarget(*reinterpret_cast< float*>(_v)); break; case 55: _t->isoUfVolume(*reinterpret_cast< float*>(_v)); break; case 56: _t->isoUfVolumeActual(*reinterpret_cast< float*>(_v)); break; case 57: _t->isoUfVolumeTarget(*reinterpret_cast< float*>(_v)); break; case 58: _t->isoUfRate(*reinterpret_cast< float*>(_v)); break; case 59: _t->isoUfRateActual(*reinterpret_cast< float*>(_v)); break; case 60: _t->isoUfRateTarget(*reinterpret_cast< float*>(_v)); break; case 61: _t->waterSampleTestResult(*reinterpret_cast< float*>(_v)); break; case 62: _t->txCode(*reinterpret_cast< QString*>(_v)); break; case 63: _t->notification(*reinterpret_cast< QString*>(_v)); break; default: break; } } else if (_c == QMetaObject::ResetProperty) { } #endif // QT_NO_PROPERTIES } QT_INIT_METAOBJECT const QMetaObject View::VPostTreatmentAdjustmentTreatmentLog::staticMetaObject = { { QMetaObject::SuperData::link(), qt_meta_stringdata_View__VPostTreatmentAdjustmentTreatmentLog.data, qt_meta_data_View__VPostTreatmentAdjustmentTreatmentLog, qt_static_metacall, nullptr, nullptr } }; const QMetaObject *View::VPostTreatmentAdjustmentTreatmentLog::metaObject() const { return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject; } void *View::VPostTreatmentAdjustmentTreatmentLog::qt_metacast(const char *_clname) { if (!_clname) return nullptr; if (!strcmp(_clname, qt_meta_stringdata_View__VPostTreatmentAdjustmentTreatmentLog.stringdata0)) return static_cast(this); return VAdjustmentResponseBase::qt_metacast(_clname); } int View::VPostTreatmentAdjustmentTreatmentLog::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = VAdjustmentResponseBase::qt_metacall(_c, _id, _a); if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { if (_id < 70) qt_static_metacall(this, _c, _id, _a); _id -= 70; } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) { if (_id < 70) *reinterpret_cast(_a[0]) = -1; _id -= 70; } #ifndef QT_NO_PROPERTIES else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) { qt_static_metacall(this, _c, _id, _a); _id -= 64; } else if (_c == QMetaObject::QueryPropertyDesignable) { _id -= 64; } else if (_c == QMetaObject::QueryPropertyScriptable) { _id -= 64; } else if (_c == QMetaObject::QueryPropertyStored) { _id -= 64; } else if (_c == QMetaObject::QueryPropertyEditable) { _id -= 64; } else if (_c == QMetaObject::QueryPropertyUser) { _id -= 64; } #endif // QT_NO_PROPERTIES return _id; } // SIGNAL 0 void View::VPostTreatmentAdjustmentTreatmentLog::adjustmentTriggered(const bool & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 0, _a); } // SIGNAL 1 void View::VPostTreatmentAdjustmentTreatmentLog::patientIDChanged(const QString & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 1, _a); } // SIGNAL 2 void View::VPostTreatmentAdjustmentTreatmentLog::bloodFlowRateChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 2, _a); } // SIGNAL 3 void View::VPostTreatmentAdjustmentTreatmentLog::bloodFlowRateActualChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 3, _a); } // SIGNAL 4 void View::VPostTreatmentAdjustmentTreatmentLog::dialysateFlowRateChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 4, _a); } // SIGNAL 5 void View::VPostTreatmentAdjustmentTreatmentLog::dialysateFlowRateActualChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 5, _a); } // SIGNAL 6 void View::VPostTreatmentAdjustmentTreatmentLog::treatmentDurationChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 6, _a); } // SIGNAL 7 void View::VPostTreatmentAdjustmentTreatmentLog::treatmentDurationActualChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 7, _a); } // SIGNAL 8 void View::VPostTreatmentAdjustmentTreatmentLog::acidConcentrateTypeChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 8, _a); } // SIGNAL 9 void View::VPostTreatmentAdjustmentTreatmentLog::acidConcentrateTypeActualChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 9, _a); } // SIGNAL 10 void View::VPostTreatmentAdjustmentTreatmentLog::bicarbonateCartridgeSizeChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 10, _a); } // SIGNAL 11 void View::VPostTreatmentAdjustmentTreatmentLog::bicarbonateCartridgeSizeActualChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 11, _a); } // SIGNAL 12 void View::VPostTreatmentAdjustmentTreatmentLog::potassiumConcentrationChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 12, _a); } // SIGNAL 13 void View::VPostTreatmentAdjustmentTreatmentLog::potassiumConcentrationActualChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 13, _a); } // SIGNAL 14 void View::VPostTreatmentAdjustmentTreatmentLog::calciumConcentrationChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 14, _a); } // SIGNAL 15 void View::VPostTreatmentAdjustmentTreatmentLog::calciumConcentrationActualChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 15, _a); } // SIGNAL 16 void View::VPostTreatmentAdjustmentTreatmentLog::bicarbonateConcentrationChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 16, _a); } // SIGNAL 17 void View::VPostTreatmentAdjustmentTreatmentLog::bicarbonateConcentrationActualChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 17, _a); } // SIGNAL 18 void View::VPostTreatmentAdjustmentTreatmentLog::sodiumConcentrationChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 18, _a); } // SIGNAL 19 void View::VPostTreatmentAdjustmentTreatmentLog::sodiumConcentrationActualChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 19, _a); } // SIGNAL 20 void View::VPostTreatmentAdjustmentTreatmentLog::vitalsIntervalChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 20, _a); } // SIGNAL 21 void View::VPostTreatmentAdjustmentTreatmentLog::vitalsIntervalActualChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 21, _a); } // SIGNAL 22 void View::VPostTreatmentAdjustmentTreatmentLog::dialyzerTypeChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 22, _a); } // SIGNAL 23 void View::VPostTreatmentAdjustmentTreatmentLog::treatmentStartEpochChanged(const QString & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 23, _a); } // SIGNAL 24 void View::VPostTreatmentAdjustmentTreatmentLog::treatmentEndEpochChanged(const QString & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 24, _a); } // SIGNAL 25 void View::VPostTreatmentAdjustmentTreatmentLog::fluidBolusVolumeChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 25, _a); } // SIGNAL 26 void View::VPostTreatmentAdjustmentTreatmentLog::fluidBolusVolumeActualChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 26, _a); } // SIGNAL 27 void View::VPostTreatmentAdjustmentTreatmentLog::heparinTypeChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 27, _a); } // SIGNAL 28 void View::VPostTreatmentAdjustmentTreatmentLog::heparinDeliveryDurationChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 28, _a); } // SIGNAL 29 void View::VPostTreatmentAdjustmentTreatmentLog::heparinDeliveryDurationActualChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 29, _a); } // SIGNAL 30 void View::VPostTreatmentAdjustmentTreatmentLog::treatmentModalityChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 30, _a); } // SIGNAL 31 void View::VPostTreatmentAdjustmentTreatmentLog::treatmentModalityActualChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 31, _a); } // SIGNAL 32 void View::VPostTreatmentAdjustmentTreatmentLog::hDFOperatingModeChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 32, _a); } // SIGNAL 33 void View::VPostTreatmentAdjustmentTreatmentLog::hDFOperatingModeActualChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 33, _a); } // SIGNAL 34 void View::VPostTreatmentAdjustmentTreatmentLog::hepatitisStatusChanged(const quint32 & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 34, _a); } // SIGNAL 35 void View::VPostTreatmentAdjustmentTreatmentLog::dialysateTemperatureChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 35, _a); } // SIGNAL 36 void View::VPostTreatmentAdjustmentTreatmentLog::dialysateTemperatureActualChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 36, _a); } // SIGNAL 37 void View::VPostTreatmentAdjustmentTreatmentLog::dialysateVolumeUsedChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 37, _a); } // SIGNAL 38 void View::VPostTreatmentAdjustmentTreatmentLog::heparinBolusVolumeChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 38, _a); } // SIGNAL 39 void View::VPostTreatmentAdjustmentTreatmentLog::heparinBolusVolumeActualChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 39, _a); } // SIGNAL 40 void View::VPostTreatmentAdjustmentTreatmentLog::heparinDispenseRateChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 40, _a); } // SIGNAL 41 void View::VPostTreatmentAdjustmentTreatmentLog::heparinDispenseRateActualChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 41, _a); } // SIGNAL 42 void View::VPostTreatmentAdjustmentTreatmentLog::heparinDeliveredVolumeChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 42, _a); } // SIGNAL 43 void View::VPostTreatmentAdjustmentTreatmentLog::uFVolumeChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 43, _a); } // SIGNAL 44 void View::VPostTreatmentAdjustmentTreatmentLog::uFVolumeActualChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 44, _a); } // SIGNAL 45 void View::VPostTreatmentAdjustmentTreatmentLog::uFVolumeTargetChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 45, _a); } // SIGNAL 46 void View::VPostTreatmentAdjustmentTreatmentLog::uFRateChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 46, _a); } // SIGNAL 47 void View::VPostTreatmentAdjustmentTreatmentLog::uFRateActualChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 47, _a); } // SIGNAL 48 void View::VPostTreatmentAdjustmentTreatmentLog::uFRateTargetChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 48, _a); } // SIGNAL 49 void View::VPostTreatmentAdjustmentTreatmentLog::substitutionVolumeChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 49, _a); } // SIGNAL 50 void View::VPostTreatmentAdjustmentTreatmentLog::substitutionVolumeActualChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 50, _a); } // SIGNAL 51 void View::VPostTreatmentAdjustmentTreatmentLog::substitutionVolumeTargetChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 51, _a); } // SIGNAL 52 void View::VPostTreatmentAdjustmentTreatmentLog::substitutionRateChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 52, _a); } // SIGNAL 53 void View::VPostTreatmentAdjustmentTreatmentLog::substitutionRateActualChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 53, _a); } // SIGNAL 54 void View::VPostTreatmentAdjustmentTreatmentLog::substitutionRateTargetChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 54, _a); } // SIGNAL 55 void View::VPostTreatmentAdjustmentTreatmentLog::isoUfVolumeChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 55, _a); } // SIGNAL 56 void View::VPostTreatmentAdjustmentTreatmentLog::isoUfVolumeActualChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 56, _a); } // SIGNAL 57 void View::VPostTreatmentAdjustmentTreatmentLog::isoUfVolumeTargetChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 57, _a); } // SIGNAL 58 void View::VPostTreatmentAdjustmentTreatmentLog::isoUfRateChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 58, _a); } // SIGNAL 59 void View::VPostTreatmentAdjustmentTreatmentLog::isoUfRateActualChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 59, _a); } // SIGNAL 60 void View::VPostTreatmentAdjustmentTreatmentLog::isoUfRateTargetChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 60, _a); } // SIGNAL 61 void View::VPostTreatmentAdjustmentTreatmentLog::waterSampleTestResultChanged(const float & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 61, _a); } // SIGNAL 62 void View::VPostTreatmentAdjustmentTreatmentLog::txCodeChanged(const QString & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 62, _a); } // SIGNAL 63 void View::VPostTreatmentAdjustmentTreatmentLog::notificationChanged(const QString & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 63, _a); } // SIGNAL 64 void View::VPostTreatmentAdjustmentTreatmentLog::didAdjustment(const AdjustTreatmentLogRequestData & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 64, _a); } QT_WARNING_POP QT_END_MOC_NAMESPACE