Index: gcc_64_release/moc_VPostTreatmentAdjustTreatmentLog.cpp =================================================================== diff -u -rbfa34189f891c087e7ca880864417e319acc44a4 -r3cbe945884a2dba098c11e6743d396c15a18db0e --- gcc_64_release/moc_VPostTreatmentAdjustTreatmentLog.cpp (.../moc_VPostTreatmentAdjustTreatmentLog.cpp) (revision bfa34189f891c087e7ca880864417e319acc44a4) +++ gcc_64_release/moc_VPostTreatmentAdjustTreatmentLog.cpp (.../moc_VPostTreatmentAdjustTreatmentLog.cpp) (revision 3cbe945884a2dba098c11e6743d396c15a18db0e) @@ -22,8 +22,8 @@ QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED struct qt_meta_stringdata_View__VPostTreatmentAdjustmentTreatmentLog_t { - QByteArrayData data[206]; - char stringdata0[4549]; + QByteArrayData data[203]; + char stringdata0[4484]; }; #define QT_MOC_LITERAL(idx, ofs, len) \ Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \ @@ -38,212 +38,208 @@ 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, 25), // "secondaryPatientIDChanged" -QT_MOC_LITERAL(7, 130, 19), // "vsecondaryPatientID" -QT_MOC_LITERAL(8, 150, 20), // "bloodFlowRateChanged" -QT_MOC_LITERAL(9, 171, 14), // "vbloodFlowRate" -QT_MOC_LITERAL(10, 186, 26), // "bloodFlowRateActualChanged" -QT_MOC_LITERAL(11, 213, 20), // "vbloodFlowRateActual" -QT_MOC_LITERAL(12, 234, 24), // "dialysateFlowRateChanged" -QT_MOC_LITERAL(13, 259, 18), // "vdialysateFlowRate" -QT_MOC_LITERAL(14, 278, 30), // "dialysateFlowRateActualChanged" -QT_MOC_LITERAL(15, 309, 24), // "vdialysateFlowRateActual" -QT_MOC_LITERAL(16, 334, 24), // "treatmentDurationChanged" -QT_MOC_LITERAL(17, 359, 18), // "vtreatmentDuration" -QT_MOC_LITERAL(18, 378, 30), // "treatmentDurationActualChanged" -QT_MOC_LITERAL(19, 409, 24), // "vtreatmentDurationActual" -QT_MOC_LITERAL(20, 434, 26), // "acidConcentrateTypeChanged" -QT_MOC_LITERAL(21, 461, 20), // "vacidConcentrateType" -QT_MOC_LITERAL(22, 482, 32), // "acidConcentrateTypeActualChanged" -QT_MOC_LITERAL(23, 515, 26), // "vacidConcentrateTypeActual" -QT_MOC_LITERAL(24, 542, 31), // "bicarbonateCartridgeSizeChanged" -QT_MOC_LITERAL(25, 574, 25), // "vbicarbonateCartridgeSize" -QT_MOC_LITERAL(26, 600, 37), // "bicarbonateCartridgeSizeActua..." -QT_MOC_LITERAL(27, 638, 31), // "vbicarbonateCartridgeSizeActual" -QT_MOC_LITERAL(28, 670, 29), // "potassiumConcentrationChanged" -QT_MOC_LITERAL(29, 700, 23), // "vpotassiumConcentration" -QT_MOC_LITERAL(30, 724, 35), // "potassiumConcentrationActualC..." -QT_MOC_LITERAL(31, 760, 29), // "vpotassiumConcentrationActual" -QT_MOC_LITERAL(32, 790, 27), // "calciumConcentrationChanged" -QT_MOC_LITERAL(33, 818, 21), // "vcalciumConcentration" -QT_MOC_LITERAL(34, 840, 33), // "calciumConcentrationActualCha..." -QT_MOC_LITERAL(35, 874, 27), // "vcalciumConcentrationActual" -QT_MOC_LITERAL(36, 902, 31), // "bicarbonateConcentrationChanged" -QT_MOC_LITERAL(37, 934, 25), // "vbicarbonateConcentration" -QT_MOC_LITERAL(38, 960, 37), // "bicarbonateConcentrationActua..." -QT_MOC_LITERAL(39, 998, 31), // "vbicarbonateConcentrationActual" -QT_MOC_LITERAL(40, 1030, 26), // "sodiumConcentrationChanged" -QT_MOC_LITERAL(41, 1057, 20), // "vsodiumConcentration" -QT_MOC_LITERAL(42, 1078, 32), // "sodiumConcentrationActualChanged" -QT_MOC_LITERAL(43, 1111, 26), // "vsodiumConcentrationActual" -QT_MOC_LITERAL(44, 1138, 21), // "vitalsIntervalChanged" -QT_MOC_LITERAL(45, 1160, 15), // "vvitalsInterval" -QT_MOC_LITERAL(46, 1176, 27), // "vitalsIntervalActualChanged" -QT_MOC_LITERAL(47, 1204, 21), // "vvitalsIntervalActual" -QT_MOC_LITERAL(48, 1226, 19), // "dialyzerTypeChanged" -QT_MOC_LITERAL(49, 1246, 13), // "vdialyzerType" -QT_MOC_LITERAL(50, 1260, 26), // "treatmentStartEpochChanged" -QT_MOC_LITERAL(51, 1287, 20), // "vtreatmentStartEpoch" -QT_MOC_LITERAL(52, 1308, 24), // "treatmentEndEpochChanged" -QT_MOC_LITERAL(53, 1333, 18), // "vtreatmentEndEpoch" -QT_MOC_LITERAL(54, 1352, 23), // "fluidBolusVolumeChanged" -QT_MOC_LITERAL(55, 1376, 17), // "vfluidBolusVolume" -QT_MOC_LITERAL(56, 1394, 29), // "fluidBolusVolumeActualChanged" -QT_MOC_LITERAL(57, 1424, 23), // "vfluidBolusVolumeActual" -QT_MOC_LITERAL(58, 1448, 18), // "heparinTypeChanged" -QT_MOC_LITERAL(59, 1467, 12), // "vheparinType" -QT_MOC_LITERAL(60, 1480, 30), // "heparinDeliveryDurationChanged" -QT_MOC_LITERAL(61, 1511, 24), // "vheparinDeliveryDuration" -QT_MOC_LITERAL(62, 1536, 36), // "heparinDeliveryDurationActual..." -QT_MOC_LITERAL(63, 1573, 30), // "vheparinDeliveryDurationActual" -QT_MOC_LITERAL(64, 1604, 24), // "treatmentModalityChanged" -QT_MOC_LITERAL(65, 1629, 18), // "vtreatmentModality" -QT_MOC_LITERAL(66, 1648, 30), // "treatmentModalityActualChanged" -QT_MOC_LITERAL(67, 1679, 24), // "vtreatmentModalityActual" -QT_MOC_LITERAL(68, 1704, 23), // "hDFOperatingModeChanged" -QT_MOC_LITERAL(69, 1728, 17), // "vhDFOperatingMode" -QT_MOC_LITERAL(70, 1746, 29), // "hDFOperatingModeActualChanged" -QT_MOC_LITERAL(71, 1776, 23), // "vhDFOperatingModeActual" -QT_MOC_LITERAL(72, 1800, 22), // "hepatitisStatusChanged" -QT_MOC_LITERAL(73, 1823, 16), // "vhepatitisStatus" -QT_MOC_LITERAL(74, 1840, 27), // "dialysateTemperatureChanged" -QT_MOC_LITERAL(75, 1868, 21), // "vdialysateTemperature" -QT_MOC_LITERAL(76, 1890, 33), // "dialysateTemperatureActualCha..." -QT_MOC_LITERAL(77, 1924, 27), // "vdialysateTemperatureActual" -QT_MOC_LITERAL(78, 1952, 26), // "dialysateVolumeUsedChanged" -QT_MOC_LITERAL(79, 1979, 20), // "vdialysateVolumeUsed" -QT_MOC_LITERAL(80, 2000, 25), // "heparinBolusVolumeChanged" -QT_MOC_LITERAL(81, 2026, 19), // "vheparinBolusVolume" -QT_MOC_LITERAL(82, 2046, 31), // "heparinBolusVolumeActualChanged" -QT_MOC_LITERAL(83, 2078, 25), // "vheparinBolusVolumeActual" -QT_MOC_LITERAL(84, 2104, 26), // "heparinDispenseRateChanged" -QT_MOC_LITERAL(85, 2131, 20), // "vheparinDispenseRate" -QT_MOC_LITERAL(86, 2152, 32), // "heparinDispenseRateActualChanged" -QT_MOC_LITERAL(87, 2185, 26), // "vheparinDispenseRateActual" -QT_MOC_LITERAL(88, 2212, 29), // "heparinDeliveredVolumeChanged" -QT_MOC_LITERAL(89, 2242, 23), // "vheparinDeliveredVolume" -QT_MOC_LITERAL(90, 2266, 15), // "uFVolumeChanged" -QT_MOC_LITERAL(91, 2282, 9), // "vuFVolume" -QT_MOC_LITERAL(92, 2292, 21), // "uFVolumeActualChanged" -QT_MOC_LITERAL(93, 2314, 15), // "vuFVolumeActual" -QT_MOC_LITERAL(94, 2330, 21), // "uFVolumeTargetChanged" -QT_MOC_LITERAL(95, 2352, 15), // "vuFVolumeTarget" -QT_MOC_LITERAL(96, 2368, 13), // "uFRateChanged" -QT_MOC_LITERAL(97, 2382, 7), // "vuFRate" -QT_MOC_LITERAL(98, 2390, 19), // "uFRateActualChanged" -QT_MOC_LITERAL(99, 2410, 13), // "vuFRateActual" -QT_MOC_LITERAL(100, 2424, 19), // "uFRateTargetChanged" -QT_MOC_LITERAL(101, 2444, 13), // "vuFRateTarget" -QT_MOC_LITERAL(102, 2458, 25), // "substitutionVolumeChanged" -QT_MOC_LITERAL(103, 2484, 19), // "vsubstitutionVolume" -QT_MOC_LITERAL(104, 2504, 31), // "substitutionVolumeActualChanged" -QT_MOC_LITERAL(105, 2536, 25), // "vsubstitutionVolumeActual" -QT_MOC_LITERAL(106, 2562, 31), // "substitutionVolumeTargetChanged" -QT_MOC_LITERAL(107, 2594, 25), // "vsubstitutionVolumeTarget" -QT_MOC_LITERAL(108, 2620, 23), // "substitutionRateChanged" -QT_MOC_LITERAL(109, 2644, 17), // "vsubstitutionRate" -QT_MOC_LITERAL(110, 2662, 29), // "substitutionRateActualChanged" -QT_MOC_LITERAL(111, 2692, 23), // "vsubstitutionRateActual" -QT_MOC_LITERAL(112, 2716, 29), // "substitutionRateTargetChanged" -QT_MOC_LITERAL(113, 2746, 23), // "vsubstitutionRateTarget" -QT_MOC_LITERAL(114, 2770, 18), // "isoUfVolumeChanged" -QT_MOC_LITERAL(115, 2789, 12), // "visoUfVolume" -QT_MOC_LITERAL(116, 2802, 24), // "isoUfVolumeActualChanged" -QT_MOC_LITERAL(117, 2827, 18), // "visoUfVolumeActual" -QT_MOC_LITERAL(118, 2846, 24), // "isoUfVolumeTargetChanged" -QT_MOC_LITERAL(119, 2871, 18), // "visoUfVolumeTarget" -QT_MOC_LITERAL(120, 2890, 16), // "isoUfRateChanged" -QT_MOC_LITERAL(121, 2907, 10), // "visoUfRate" -QT_MOC_LITERAL(122, 2918, 22), // "isoUfRateActualChanged" -QT_MOC_LITERAL(123, 2941, 16), // "visoUfRateActual" -QT_MOC_LITERAL(124, 2958, 22), // "isoUfRateTargetChanged" -QT_MOC_LITERAL(125, 2981, 16), // "visoUfRateTarget" -QT_MOC_LITERAL(126, 2998, 28), // "waterSampleTestResultChanged" -QT_MOC_LITERAL(127, 3027, 22), // "vwaterSampleTestResult" -QT_MOC_LITERAL(128, 3050, 13), // "txCodeChanged" -QT_MOC_LITERAL(129, 3064, 7), // "vtxCode" -QT_MOC_LITERAL(130, 3072, 19), // "notificationChanged" -QT_MOC_LITERAL(131, 3092, 13), // "vnotification" -QT_MOC_LITERAL(132, 3106, 13), // "didAdjustment" -QT_MOC_LITERAL(133, 3120, 29), // "AdjustTreatmentLogRequestData" -QT_MOC_LITERAL(134, 3150, 5), // "vData" -QT_MOC_LITERAL(135, 3156, 15), // "onActionReceive" -QT_MOC_LITERAL(136, 3172, 30), // "AdjustTreatmentLogResponseData" -QT_MOC_LITERAL(137, 3203, 21), // "TreatmentLogAvrgeData" -QT_MOC_LITERAL(138, 3225, 21), // "TreatmentLogAlarmData" -QT_MOC_LITERAL(139, 3247, 21), // "TreatmentLogEventData" -QT_MOC_LITERAL(140, 3269, 9), // "doRequest" -QT_MOC_LITERAL(141, 3279, 10), // "adjustment" -QT_MOC_LITERAL(142, 3290, 9), // "patientID" -QT_MOC_LITERAL(143, 3300, 18), // "secondaryPatientID" -QT_MOC_LITERAL(144, 3319, 13), // "bloodFlowRate" -QT_MOC_LITERAL(145, 3333, 19), // "bloodFlowRateActual" -QT_MOC_LITERAL(146, 3353, 17), // "dialysateFlowRate" -QT_MOC_LITERAL(147, 3371, 23), // "dialysateFlowRateActual" -QT_MOC_LITERAL(148, 3395, 17), // "treatmentDuration" -QT_MOC_LITERAL(149, 3413, 23), // "treatmentDurationActual" -QT_MOC_LITERAL(150, 3437, 19), // "acidConcentrateType" -QT_MOC_LITERAL(151, 3457, 25), // "acidConcentrateTypeActual" -QT_MOC_LITERAL(152, 3483, 24), // "bicarbonateCartridgeSize" -QT_MOC_LITERAL(153, 3508, 30), // "bicarbonateCartridgeSizeActual" -QT_MOC_LITERAL(154, 3539, 22), // "potassiumConcentration" -QT_MOC_LITERAL(155, 3562, 28), // "potassiumConcentrationActual" -QT_MOC_LITERAL(156, 3591, 20), // "calciumConcentration" -QT_MOC_LITERAL(157, 3612, 26), // "calciumConcentrationActual" -QT_MOC_LITERAL(158, 3639, 24), // "bicarbonateConcentration" -QT_MOC_LITERAL(159, 3664, 30), // "bicarbonateConcentrationActual" -QT_MOC_LITERAL(160, 3695, 19), // "sodiumConcentration" -QT_MOC_LITERAL(161, 3715, 25), // "sodiumConcentrationActual" -QT_MOC_LITERAL(162, 3741, 14), // "vitalsInterval" -QT_MOC_LITERAL(163, 3756, 20), // "vitalsIntervalActual" -QT_MOC_LITERAL(164, 3777, 12), // "dialyzerType" -QT_MOC_LITERAL(165, 3790, 19), // "treatmentStartEpoch" -QT_MOC_LITERAL(166, 3810, 17), // "treatmentEndEpoch" -QT_MOC_LITERAL(167, 3828, 16), // "fluidBolusVolume" -QT_MOC_LITERAL(168, 3845, 22), // "fluidBolusVolumeActual" -QT_MOC_LITERAL(169, 3868, 11), // "heparinType" -QT_MOC_LITERAL(170, 3880, 23), // "heparinDeliveryDuration" -QT_MOC_LITERAL(171, 3904, 29), // "heparinDeliveryDurationActual" -QT_MOC_LITERAL(172, 3934, 17), // "treatmentModality" -QT_MOC_LITERAL(173, 3952, 23), // "treatmentModalityActual" -QT_MOC_LITERAL(174, 3976, 16), // "hDFOperatingMode" -QT_MOC_LITERAL(175, 3993, 22), // "hDFOperatingModeActual" -QT_MOC_LITERAL(176, 4016, 15), // "hepatitisStatus" -QT_MOC_LITERAL(177, 4032, 20), // "dialysateTemperature" -QT_MOC_LITERAL(178, 4053, 26), // "dialysateTemperatureActual" -QT_MOC_LITERAL(179, 4080, 19), // "dialysateVolumeUsed" -QT_MOC_LITERAL(180, 4100, 18), // "heparinBolusVolume" -QT_MOC_LITERAL(181, 4119, 24), // "heparinBolusVolumeActual" -QT_MOC_LITERAL(182, 4144, 19), // "heparinDispenseRate" -QT_MOC_LITERAL(183, 4164, 25), // "heparinDispenseRateActual" -QT_MOC_LITERAL(184, 4190, 22), // "heparinDeliveredVolume" -QT_MOC_LITERAL(185, 4213, 8), // "uFVolume" -QT_MOC_LITERAL(186, 4222, 14), // "uFVolumeActual" -QT_MOC_LITERAL(187, 4237, 14), // "uFVolumeTarget" -QT_MOC_LITERAL(188, 4252, 6), // "uFRate" -QT_MOC_LITERAL(189, 4259, 12), // "uFRateActual" -QT_MOC_LITERAL(190, 4272, 12), // "uFRateTarget" -QT_MOC_LITERAL(191, 4285, 18), // "substitutionVolume" -QT_MOC_LITERAL(192, 4304, 24), // "substitutionVolumeActual" -QT_MOC_LITERAL(193, 4329, 24), // "substitutionVolumeTarget" -QT_MOC_LITERAL(194, 4354, 16), // "substitutionRate" -QT_MOC_LITERAL(195, 4371, 22), // "substitutionRateActual" -QT_MOC_LITERAL(196, 4394, 22), // "substitutionRateTarget" -QT_MOC_LITERAL(197, 4417, 11), // "isoUfVolume" -QT_MOC_LITERAL(198, 4429, 17), // "isoUfVolumeActual" -QT_MOC_LITERAL(199, 4447, 17), // "isoUfVolumeTarget" -QT_MOC_LITERAL(200, 4465, 9), // "isoUfRate" -QT_MOC_LITERAL(201, 4475, 15), // "isoUfRateActual" -QT_MOC_LITERAL(202, 4491, 15), // "isoUfRateTarget" -QT_MOC_LITERAL(203, 4507, 21), // "waterSampleTestResult" -QT_MOC_LITERAL(204, 4529, 6), // "txCode" -QT_MOC_LITERAL(205, 4536, 12) // "notification" +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" - "secondaryPatientIDChanged\0vsecondaryPatientID\0" "bloodFlowRateChanged\0vbloodFlowRate\0" "bloodFlowRateActualChanged\0" "vbloodFlowRateActual\0dialysateFlowRateChanged\0" @@ -336,11 +332,11 @@ "AdjustTreatmentLogResponseData\0" "TreatmentLogAvrgeData\0TreatmentLogAlarmData\0" "TreatmentLogEventData\0doRequest\0" - "adjustment\0patientID\0secondaryPatientID\0" - "bloodFlowRate\0bloodFlowRateActual\0" - "dialysateFlowRate\0dialysateFlowRateActual\0" - "treatmentDuration\0treatmentDurationActual\0" - "acidConcentrateType\0acidConcentrateTypeActual\0" + "adjustment\0patientID\0bloodFlowRate\0" + "bloodFlowRateActual\0dialysateFlowRate\0" + "dialysateFlowRateActual\0treatmentDuration\0" + "treatmentDurationActual\0acidConcentrateType\0" + "acidConcentrateTypeActual\0" "bicarbonateCartridgeSize\0" "bicarbonateCartridgeSizeActual\0" "potassiumConcentration\0" @@ -381,92 +377,91 @@ 8, // revision 0, // classname 0, 0, // classinfo - 71, 14, // methods - 65, 580, // properties + 70, 14, // methods + 64, 572, // properties 0, 0, // enums/sets 0, 0, // constructors 0, // flags - 66, // signalCount + 65, // signalCount // signals: name, argc, parameters, tag, flags - 1, 1, 369, 2, 0x06 /* Public */, - 4, 1, 372, 2, 0x06 /* Public */, - 6, 1, 375, 2, 0x06 /* Public */, - 8, 1, 378, 2, 0x06 /* Public */, - 10, 1, 381, 2, 0x06 /* Public */, - 12, 1, 384, 2, 0x06 /* Public */, - 14, 1, 387, 2, 0x06 /* Public */, - 16, 1, 390, 2, 0x06 /* Public */, - 18, 1, 393, 2, 0x06 /* Public */, - 20, 1, 396, 2, 0x06 /* Public */, - 22, 1, 399, 2, 0x06 /* Public */, - 24, 1, 402, 2, 0x06 /* Public */, - 26, 1, 405, 2, 0x06 /* Public */, - 28, 1, 408, 2, 0x06 /* Public */, - 30, 1, 411, 2, 0x06 /* Public */, - 32, 1, 414, 2, 0x06 /* Public */, - 34, 1, 417, 2, 0x06 /* Public */, - 36, 1, 420, 2, 0x06 /* Public */, - 38, 1, 423, 2, 0x06 /* Public */, - 40, 1, 426, 2, 0x06 /* Public */, - 42, 1, 429, 2, 0x06 /* Public */, - 44, 1, 432, 2, 0x06 /* Public */, - 46, 1, 435, 2, 0x06 /* Public */, - 48, 1, 438, 2, 0x06 /* Public */, - 50, 1, 441, 2, 0x06 /* Public */, - 52, 1, 444, 2, 0x06 /* Public */, - 54, 1, 447, 2, 0x06 /* Public */, - 56, 1, 450, 2, 0x06 /* Public */, - 58, 1, 453, 2, 0x06 /* Public */, - 60, 1, 456, 2, 0x06 /* Public */, - 62, 1, 459, 2, 0x06 /* Public */, - 64, 1, 462, 2, 0x06 /* Public */, - 66, 1, 465, 2, 0x06 /* Public */, - 68, 1, 468, 2, 0x06 /* Public */, - 70, 1, 471, 2, 0x06 /* Public */, - 72, 1, 474, 2, 0x06 /* Public */, - 74, 1, 477, 2, 0x06 /* Public */, - 76, 1, 480, 2, 0x06 /* Public */, - 78, 1, 483, 2, 0x06 /* Public */, - 80, 1, 486, 2, 0x06 /* Public */, - 82, 1, 489, 2, 0x06 /* Public */, - 84, 1, 492, 2, 0x06 /* Public */, - 86, 1, 495, 2, 0x06 /* Public */, - 88, 1, 498, 2, 0x06 /* Public */, - 90, 1, 501, 2, 0x06 /* Public */, - 92, 1, 504, 2, 0x06 /* Public */, - 94, 1, 507, 2, 0x06 /* Public */, - 96, 1, 510, 2, 0x06 /* Public */, - 98, 1, 513, 2, 0x06 /* Public */, - 100, 1, 516, 2, 0x06 /* Public */, - 102, 1, 519, 2, 0x06 /* Public */, - 104, 1, 522, 2, 0x06 /* Public */, - 106, 1, 525, 2, 0x06 /* Public */, - 108, 1, 528, 2, 0x06 /* Public */, - 110, 1, 531, 2, 0x06 /* Public */, - 112, 1, 534, 2, 0x06 /* Public */, - 114, 1, 537, 2, 0x06 /* Public */, - 116, 1, 540, 2, 0x06 /* Public */, - 118, 1, 543, 2, 0x06 /* Public */, - 120, 1, 546, 2, 0x06 /* Public */, - 122, 1, 549, 2, 0x06 /* Public */, - 124, 1, 552, 2, 0x06 /* Public */, - 126, 1, 555, 2, 0x06 /* Public */, - 128, 1, 558, 2, 0x06 /* Public */, - 130, 1, 561, 2, 0x06 /* Public */, - 132, 1, 564, 2, 0x06 /* Public */, + 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 - 135, 1, 567, 2, 0x08 /* Private */, - 135, 1, 570, 2, 0x08 /* Private */, - 135, 1, 573, 2, 0x08 /* Private */, - 135, 1, 576, 2, 0x08 /* Private */, - 140, 0, 579, 2, 0x0a /* Public */, + 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::QString, 7, + QMetaType::Void, QMetaType::UInt, 7, QMetaType::Void, QMetaType::UInt, 9, QMetaType::Void, QMetaType::UInt, 11, QMetaType::Void, QMetaType::UInt, 13, @@ -487,9 +482,9 @@ QMetaType::Void, QMetaType::UInt, 43, QMetaType::Void, QMetaType::UInt, 45, QMetaType::Void, QMetaType::UInt, 47, - QMetaType::Void, QMetaType::UInt, 49, + QMetaType::Void, QMetaType::QString, 49, QMetaType::Void, QMetaType::QString, 51, - QMetaType::Void, QMetaType::QString, 53, + QMetaType::Void, QMetaType::UInt, 53, QMetaType::Void, QMetaType::UInt, 55, QMetaType::Void, QMetaType::UInt, 57, QMetaType::Void, QMetaType::UInt, 59, @@ -499,7 +494,7 @@ QMetaType::Void, QMetaType::UInt, 67, QMetaType::Void, QMetaType::UInt, 69, QMetaType::Void, QMetaType::UInt, 71, - QMetaType::Void, QMetaType::UInt, 73, + QMetaType::Void, QMetaType::Float, 73, QMetaType::Void, QMetaType::Float, 75, QMetaType::Void, QMetaType::Float, 77, QMetaType::Void, QMetaType::Float, 79, @@ -526,22 +521,23 @@ QMetaType::Void, QMetaType::Float, 121, QMetaType::Void, QMetaType::Float, 123, QMetaType::Void, QMetaType::Float, 125, - QMetaType::Void, QMetaType::Float, 127, + QMetaType::Void, QMetaType::QString, 127, QMetaType::Void, QMetaType::QString, 129, - QMetaType::Void, QMetaType::QString, 131, - QMetaType::Void, 0x80000000 | 133, 134, + QMetaType::Void, 0x80000000 | 131, 132, // slots: parameters - QMetaType::Void, 0x80000000 | 136, 134, - QMetaType::Void, 0x80000000 | 137, 134, - QMetaType::Void, 0x80000000 | 138, 134, - QMetaType::Void, 0x80000000 | 139, 134, + 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 - 141, QMetaType::Bool, 0x00495003, - 142, QMetaType::QString, 0x00495003, - 143, QMetaType::QString, 0x00495003, + 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, @@ -560,21 +556,21 @@ 159, QMetaType::UInt, 0x00495003, 160, QMetaType::UInt, 0x00495003, 161, QMetaType::UInt, 0x00495003, - 162, QMetaType::UInt, 0x00495003, - 163, QMetaType::UInt, 0x00495003, + 162, QMetaType::QString, 0x00495003, + 163, QMetaType::QString, 0x00495003, 164, QMetaType::UInt, 0x00495003, - 165, QMetaType::QString, 0x00495003, - 166, QMetaType::QString, 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::UInt, 0x00495003, - 175, QMetaType::UInt, 0x00495003, - 176, 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, @@ -599,11 +595,8 @@ 198, QMetaType::Float, 0x00495003, 199, QMetaType::Float, 0x00495003, 200, QMetaType::Float, 0x00495003, - 201, QMetaType::Float, 0x00495003, - 202, QMetaType::Float, 0x00495003, - 203, QMetaType::Float, 0x00495003, - 204, QMetaType::QString, 0x00495003, - 205, QMetaType::QString, 0x00495003, + 201, QMetaType::QString, 0x00495003, + 202, QMetaType::QString, 0x00495003, // properties: notify_signal_id 0, @@ -670,7 +663,6 @@ 61, 62, 63, - 64, 0 // eod }; @@ -683,75 +675,74 @@ 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->secondaryPatientIDChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break; - case 3: _t->bloodFlowRateChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 4: _t->bloodFlowRateActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 5: _t->dialysateFlowRateChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 6: _t->dialysateFlowRateActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 7: _t->treatmentDurationChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 8: _t->treatmentDurationActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 9: _t->acidConcentrateTypeChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 10: _t->acidConcentrateTypeActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 11: _t->bicarbonateCartridgeSizeChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 12: _t->bicarbonateCartridgeSizeActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 13: _t->potassiumConcentrationChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 14: _t->potassiumConcentrationActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 15: _t->calciumConcentrationChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 16: _t->calciumConcentrationActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 17: _t->bicarbonateConcentrationChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 18: _t->bicarbonateConcentrationActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 19: _t->sodiumConcentrationChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 20: _t->sodiumConcentrationActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 21: _t->vitalsIntervalChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 22: _t->vitalsIntervalActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 23: _t->dialyzerTypeChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 24: _t->treatmentStartEpochChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break; - case 25: _t->treatmentEndEpochChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break; - case 26: _t->fluidBolusVolumeChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 27: _t->fluidBolusVolumeActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 28: _t->heparinTypeChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 29: _t->heparinDeliveryDurationChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 30: _t->heparinDeliveryDurationActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 31: _t->treatmentModalityChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 32: _t->treatmentModalityActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 33: _t->hDFOperatingModeChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 34: _t->hDFOperatingModeActualChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 35: _t->hepatitisStatusChanged((*reinterpret_cast< const quint32(*)>(_a[1]))); break; - case 36: _t->dialysateTemperatureChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 37: _t->dialysateTemperatureActualChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 38: _t->dialysateVolumeUsedChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 39: _t->heparinBolusVolumeChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 40: _t->heparinBolusVolumeActualChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 41: _t->heparinDispenseRateChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 42: _t->heparinDispenseRateActualChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 43: _t->heparinDeliveredVolumeChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 44: _t->uFVolumeChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 45: _t->uFVolumeActualChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 46: _t->uFVolumeTargetChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 47: _t->uFRateChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 48: _t->uFRateActualChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 49: _t->uFRateTargetChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 50: _t->substitutionVolumeChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 51: _t->substitutionVolumeActualChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 52: _t->substitutionVolumeTargetChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 53: _t->substitutionRateChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 54: _t->substitutionRateActualChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 55: _t->substitutionRateTargetChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 56: _t->isoUfVolumeChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 57: _t->isoUfVolumeActualChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 58: _t->isoUfVolumeTargetChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 59: _t->isoUfRateChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 60: _t->isoUfRateActualChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 61: _t->isoUfRateTargetChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 62: _t->waterSampleTestResultChanged((*reinterpret_cast< const float(*)>(_a[1]))); break; - case 63: _t->txCodeChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break; - case 64: _t->notificationChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break; - case 65: _t->didAdjustment((*reinterpret_cast< const AdjustTreatmentLogRequestData(*)>(_a[1]))); break; - case 66: _t->onActionReceive((*reinterpret_cast< const AdjustTreatmentLogResponseData(*)>(_a[1]))); break; - case 67: _t->onActionReceive((*reinterpret_cast< const TreatmentLogAvrgeData(*)>(_a[1]))); break; - case 68: _t->onActionReceive((*reinterpret_cast< const TreatmentLogAlarmData(*)>(_a[1]))); break; - case 69: _t->onActionReceive((*reinterpret_cast< const TreatmentLogEventData(*)>(_a[1]))); break; - case 70: _t->doRequest(); 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) { @@ -771,450 +762,443 @@ } } { - using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const QString & ); - if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::secondaryPatientIDChanged)) { - *result = 2; - return; - } - } - { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::bloodFlowRateChanged)) { - *result = 3; + *result = 2; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::bloodFlowRateActualChanged)) { - *result = 4; + *result = 3; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::dialysateFlowRateChanged)) { - *result = 5; + *result = 4; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::dialysateFlowRateActualChanged)) { - *result = 6; + *result = 5; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::treatmentDurationChanged)) { - *result = 7; + *result = 6; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::treatmentDurationActualChanged)) { - *result = 8; + *result = 7; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::acidConcentrateTypeChanged)) { - *result = 9; + *result = 8; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::acidConcentrateTypeActualChanged)) { - *result = 10; + *result = 9; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::bicarbonateCartridgeSizeChanged)) { - *result = 11; + *result = 10; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::bicarbonateCartridgeSizeActualChanged)) { - *result = 12; + *result = 11; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::potassiumConcentrationChanged)) { - *result = 13; + *result = 12; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::potassiumConcentrationActualChanged)) { - *result = 14; + *result = 13; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::calciumConcentrationChanged)) { - *result = 15; + *result = 14; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::calciumConcentrationActualChanged)) { - *result = 16; + *result = 15; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::bicarbonateConcentrationChanged)) { - *result = 17; + *result = 16; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::bicarbonateConcentrationActualChanged)) { - *result = 18; + *result = 17; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::sodiumConcentrationChanged)) { - *result = 19; + *result = 18; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::sodiumConcentrationActualChanged)) { - *result = 20; + *result = 19; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::vitalsIntervalChanged)) { - *result = 21; + *result = 20; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::vitalsIntervalActualChanged)) { - *result = 22; + *result = 21; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::dialyzerTypeChanged)) { - *result = 23; + *result = 22; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const QString & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::treatmentStartEpochChanged)) { - *result = 24; + *result = 23; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const QString & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::treatmentEndEpochChanged)) { - *result = 25; + *result = 24; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::fluidBolusVolumeChanged)) { - *result = 26; + *result = 25; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::fluidBolusVolumeActualChanged)) { - *result = 27; + *result = 26; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::heparinTypeChanged)) { - *result = 28; + *result = 27; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::heparinDeliveryDurationChanged)) { - *result = 29; + *result = 28; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::heparinDeliveryDurationActualChanged)) { - *result = 30; + *result = 29; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::treatmentModalityChanged)) { - *result = 31; + *result = 30; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::treatmentModalityActualChanged)) { - *result = 32; + *result = 31; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::hDFOperatingModeChanged)) { - *result = 33; + *result = 32; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::hDFOperatingModeActualChanged)) { - *result = 34; + *result = 33; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const quint32 & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::hepatitisStatusChanged)) { - *result = 35; + *result = 34; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::dialysateTemperatureChanged)) { - *result = 36; + *result = 35; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::dialysateTemperatureActualChanged)) { - *result = 37; + *result = 36; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::dialysateVolumeUsedChanged)) { - *result = 38; + *result = 37; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::heparinBolusVolumeChanged)) { - *result = 39; + *result = 38; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::heparinBolusVolumeActualChanged)) { - *result = 40; + *result = 39; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::heparinDispenseRateChanged)) { - *result = 41; + *result = 40; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::heparinDispenseRateActualChanged)) { - *result = 42; + *result = 41; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::heparinDeliveredVolumeChanged)) { - *result = 43; + *result = 42; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::uFVolumeChanged)) { - *result = 44; + *result = 43; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::uFVolumeActualChanged)) { - *result = 45; + *result = 44; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::uFVolumeTargetChanged)) { - *result = 46; + *result = 45; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::uFRateChanged)) { - *result = 47; + *result = 46; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::uFRateActualChanged)) { - *result = 48; + *result = 47; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::uFRateTargetChanged)) { - *result = 49; + *result = 48; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::substitutionVolumeChanged)) { - *result = 50; + *result = 49; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::substitutionVolumeActualChanged)) { - *result = 51; + *result = 50; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::substitutionVolumeTargetChanged)) { - *result = 52; + *result = 51; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::substitutionRateChanged)) { - *result = 53; + *result = 52; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::substitutionRateActualChanged)) { - *result = 54; + *result = 53; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::substitutionRateTargetChanged)) { - *result = 55; + *result = 54; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::isoUfVolumeChanged)) { - *result = 56; + *result = 55; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::isoUfVolumeActualChanged)) { - *result = 57; + *result = 56; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::isoUfVolumeTargetChanged)) { - *result = 58; + *result = 57; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::isoUfRateChanged)) { - *result = 59; + *result = 58; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::isoUfRateActualChanged)) { - *result = 60; + *result = 59; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::isoUfRateTargetChanged)) { - *result = 61; + *result = 60; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const float & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::waterSampleTestResultChanged)) { - *result = 62; + *result = 61; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const QString & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::txCodeChanged)) { - *result = 63; + *result = 62; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const QString & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::notificationChanged)) { - *result = 64; + *result = 63; return; } } { using _t = void (VPostTreatmentAdjustmentTreatmentLog::*)(const AdjustTreatmentLogRequestData & ); if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&VPostTreatmentAdjustmentTreatmentLog::didAdjustment)) { - *result = 65; + *result = 64; return; } } @@ -1227,69 +1211,68 @@ switch (_id) { case 0: *reinterpret_cast< bool*>(_v) = _t->adjustment(); break; case 1: *reinterpret_cast< QString*>(_v) = _t->patientID(); break; - case 2: *reinterpret_cast< QString*>(_v) = _t->secondaryPatientID(); break; - case 3: *reinterpret_cast< quint32*>(_v) = _t->bloodFlowRate(); break; - case 4: *reinterpret_cast< quint32*>(_v) = _t->bloodFlowRateActual(); break; - case 5: *reinterpret_cast< quint32*>(_v) = _t->dialysateFlowRate(); break; - case 6: *reinterpret_cast< quint32*>(_v) = _t->dialysateFlowRateActual(); break; - case 7: *reinterpret_cast< quint32*>(_v) = _t->treatmentDuration(); break; - case 8: *reinterpret_cast< quint32*>(_v) = _t->treatmentDurationActual(); break; - case 9: *reinterpret_cast< quint32*>(_v) = _t->acidConcentrateType(); break; - case 10: *reinterpret_cast< quint32*>(_v) = _t->acidConcentrateTypeActual(); break; - case 11: *reinterpret_cast< quint32*>(_v) = _t->bicarbonateCartridgeSize(); break; - case 12: *reinterpret_cast< quint32*>(_v) = _t->bicarbonateCartridgeSizeActual(); break; - case 13: *reinterpret_cast< quint32*>(_v) = _t->potassiumConcentration(); break; - case 14: *reinterpret_cast< quint32*>(_v) = _t->potassiumConcentrationActual(); break; - case 15: *reinterpret_cast< quint32*>(_v) = _t->calciumConcentration(); break; - case 16: *reinterpret_cast< quint32*>(_v) = _t->calciumConcentrationActual(); break; - case 17: *reinterpret_cast< quint32*>(_v) = _t->bicarbonateConcentration(); break; - case 18: *reinterpret_cast< quint32*>(_v) = _t->bicarbonateConcentrationActual(); break; - case 19: *reinterpret_cast< quint32*>(_v) = _t->sodiumConcentration(); break; - case 20: *reinterpret_cast< quint32*>(_v) = _t->sodiumConcentrationActual(); break; - case 21: *reinterpret_cast< quint32*>(_v) = _t->vitalsInterval(); break; - case 22: *reinterpret_cast< quint32*>(_v) = _t->vitalsIntervalActual(); break; - case 23: *reinterpret_cast< quint32*>(_v) = _t->dialyzerType(); break; - case 24: *reinterpret_cast< QString*>(_v) = _t->treatmentStartEpoch(); break; - case 25: *reinterpret_cast< QString*>(_v) = _t->treatmentEndEpoch(); break; - case 26: *reinterpret_cast< quint32*>(_v) = _t->fluidBolusVolume(); break; - case 27: *reinterpret_cast< quint32*>(_v) = _t->fluidBolusVolumeActual(); break; - case 28: *reinterpret_cast< quint32*>(_v) = _t->heparinType(); break; - case 29: *reinterpret_cast< quint32*>(_v) = _t->heparinDeliveryDuration(); break; - case 30: *reinterpret_cast< quint32*>(_v) = _t->heparinDeliveryDurationActual(); break; - case 31: *reinterpret_cast< quint32*>(_v) = _t->treatmentModality(); break; - case 32: *reinterpret_cast< quint32*>(_v) = _t->treatmentModalityActual(); break; - case 33: *reinterpret_cast< quint32*>(_v) = _t->hDFOperatingMode(); break; - case 34: *reinterpret_cast< quint32*>(_v) = _t->hDFOperatingModeActual(); break; - case 35: *reinterpret_cast< quint32*>(_v) = _t->hepatitisStatus(); break; - case 36: *reinterpret_cast< float*>(_v) = _t->dialysateTemperature(); break; - case 37: *reinterpret_cast< float*>(_v) = _t->dialysateTemperatureActual(); break; - case 38: *reinterpret_cast< float*>(_v) = _t->dialysateVolumeUsed(); break; - case 39: *reinterpret_cast< float*>(_v) = _t->heparinBolusVolume(); break; - case 40: *reinterpret_cast< float*>(_v) = _t->heparinBolusVolumeActual(); break; - case 41: *reinterpret_cast< float*>(_v) = _t->heparinDispenseRate(); break; - case 42: *reinterpret_cast< float*>(_v) = _t->heparinDispenseRateActual(); break; - case 43: *reinterpret_cast< float*>(_v) = _t->heparinDeliveredVolume(); break; - case 44: *reinterpret_cast< float*>(_v) = _t->uFVolume(); break; - case 45: *reinterpret_cast< float*>(_v) = _t->uFVolumeActual(); break; - case 46: *reinterpret_cast< float*>(_v) = _t->uFVolumeTarget(); break; - case 47: *reinterpret_cast< float*>(_v) = _t->uFRate(); break; - case 48: *reinterpret_cast< float*>(_v) = _t->uFRateActual(); break; - case 49: *reinterpret_cast< float*>(_v) = _t->uFRateTarget(); break; - case 50: *reinterpret_cast< float*>(_v) = _t->substitutionVolume(); break; - case 51: *reinterpret_cast< float*>(_v) = _t->substitutionVolumeActual(); break; - case 52: *reinterpret_cast< float*>(_v) = _t->substitutionVolumeTarget(); break; - case 53: *reinterpret_cast< float*>(_v) = _t->substitutionRate(); break; - case 54: *reinterpret_cast< float*>(_v) = _t->substitutionRateActual(); break; - case 55: *reinterpret_cast< float*>(_v) = _t->substitutionRateTarget(); break; - case 56: *reinterpret_cast< float*>(_v) = _t->isoUfVolume(); break; - case 57: *reinterpret_cast< float*>(_v) = _t->isoUfVolumeActual(); break; - case 58: *reinterpret_cast< float*>(_v) = _t->isoUfVolumeTarget(); break; - case 59: *reinterpret_cast< float*>(_v) = _t->isoUfRate(); break; - case 60: *reinterpret_cast< float*>(_v) = _t->isoUfRateActual(); break; - case 61: *reinterpret_cast< float*>(_v) = _t->isoUfRateTarget(); break; - case 62: *reinterpret_cast< float*>(_v) = _t->waterSampleTestResult(); break; - case 63: *reinterpret_cast< QString*>(_v) = _t->txCode(); break; - case 64: *reinterpret_cast< QString*>(_v) = _t->notification(); 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) { @@ -1299,69 +1282,68 @@ switch (_id) { case 0: _t->adjustment(*reinterpret_cast< bool*>(_v)); break; case 1: _t->patientID(*reinterpret_cast< QString*>(_v)); break; - case 2: _t->secondaryPatientID(*reinterpret_cast< QString*>(_v)); break; - case 3: _t->bloodFlowRate(*reinterpret_cast< quint32*>(_v)); break; - case 4: _t->bloodFlowRateActual(*reinterpret_cast< quint32*>(_v)); break; - case 5: _t->dialysateFlowRate(*reinterpret_cast< quint32*>(_v)); break; - case 6: _t->dialysateFlowRateActual(*reinterpret_cast< quint32*>(_v)); break; - case 7: _t->treatmentDuration(*reinterpret_cast< quint32*>(_v)); break; - case 8: _t->treatmentDurationActual(*reinterpret_cast< quint32*>(_v)); break; - case 9: _t->acidConcentrateType(*reinterpret_cast< quint32*>(_v)); break; - case 10: _t->acidConcentrateTypeActual(*reinterpret_cast< quint32*>(_v)); break; - case 11: _t->bicarbonateCartridgeSize(*reinterpret_cast< quint32*>(_v)); break; - case 12: _t->bicarbonateCartridgeSizeActual(*reinterpret_cast< quint32*>(_v)); break; - case 13: _t->potassiumConcentration(*reinterpret_cast< quint32*>(_v)); break; - case 14: _t->potassiumConcentrationActual(*reinterpret_cast< quint32*>(_v)); break; - case 15: _t->calciumConcentration(*reinterpret_cast< quint32*>(_v)); break; - case 16: _t->calciumConcentrationActual(*reinterpret_cast< quint32*>(_v)); break; - case 17: _t->bicarbonateConcentration(*reinterpret_cast< quint32*>(_v)); break; - case 18: _t->bicarbonateConcentrationActual(*reinterpret_cast< quint32*>(_v)); break; - case 19: _t->sodiumConcentration(*reinterpret_cast< quint32*>(_v)); break; - case 20: _t->sodiumConcentrationActual(*reinterpret_cast< quint32*>(_v)); break; - case 21: _t->vitalsInterval(*reinterpret_cast< quint32*>(_v)); break; - case 22: _t->vitalsIntervalActual(*reinterpret_cast< quint32*>(_v)); break; - case 23: _t->dialyzerType(*reinterpret_cast< quint32*>(_v)); break; - case 24: _t->treatmentStartEpoch(*reinterpret_cast< QString*>(_v)); break; - case 25: _t->treatmentEndEpoch(*reinterpret_cast< QString*>(_v)); break; - case 26: _t->fluidBolusVolume(*reinterpret_cast< quint32*>(_v)); break; - case 27: _t->fluidBolusVolumeActual(*reinterpret_cast< quint32*>(_v)); break; - case 28: _t->heparinType(*reinterpret_cast< quint32*>(_v)); break; - case 29: _t->heparinDeliveryDuration(*reinterpret_cast< quint32*>(_v)); break; - case 30: _t->heparinDeliveryDurationActual(*reinterpret_cast< quint32*>(_v)); break; - case 31: _t->treatmentModality(*reinterpret_cast< quint32*>(_v)); break; - case 32: _t->treatmentModalityActual(*reinterpret_cast< quint32*>(_v)); break; - case 33: _t->hDFOperatingMode(*reinterpret_cast< quint32*>(_v)); break; - case 34: _t->hDFOperatingModeActual(*reinterpret_cast< quint32*>(_v)); break; - case 35: _t->hepatitisStatus(*reinterpret_cast< quint32*>(_v)); break; - case 36: _t->dialysateTemperature(*reinterpret_cast< float*>(_v)); break; - case 37: _t->dialysateTemperatureActual(*reinterpret_cast< float*>(_v)); break; - case 38: _t->dialysateVolumeUsed(*reinterpret_cast< float*>(_v)); break; - case 39: _t->heparinBolusVolume(*reinterpret_cast< float*>(_v)); break; - case 40: _t->heparinBolusVolumeActual(*reinterpret_cast< float*>(_v)); break; - case 41: _t->heparinDispenseRate(*reinterpret_cast< float*>(_v)); break; - case 42: _t->heparinDispenseRateActual(*reinterpret_cast< float*>(_v)); break; - case 43: _t->heparinDeliveredVolume(*reinterpret_cast< float*>(_v)); break; - case 44: _t->uFVolume(*reinterpret_cast< float*>(_v)); break; - case 45: _t->uFVolumeActual(*reinterpret_cast< float*>(_v)); break; - case 46: _t->uFVolumeTarget(*reinterpret_cast< float*>(_v)); break; - case 47: _t->uFRate(*reinterpret_cast< float*>(_v)); break; - case 48: _t->uFRateActual(*reinterpret_cast< float*>(_v)); break; - case 49: _t->uFRateTarget(*reinterpret_cast< float*>(_v)); break; - case 50: _t->substitutionVolume(*reinterpret_cast< float*>(_v)); break; - case 51: _t->substitutionVolumeActual(*reinterpret_cast< float*>(_v)); break; - case 52: _t->substitutionVolumeTarget(*reinterpret_cast< float*>(_v)); break; - case 53: _t->substitutionRate(*reinterpret_cast< float*>(_v)); break; - case 54: _t->substitutionRateActual(*reinterpret_cast< float*>(_v)); break; - case 55: _t->substitutionRateTarget(*reinterpret_cast< float*>(_v)); break; - case 56: _t->isoUfVolume(*reinterpret_cast< float*>(_v)); break; - case 57: _t->isoUfVolumeActual(*reinterpret_cast< float*>(_v)); break; - case 58: _t->isoUfVolumeTarget(*reinterpret_cast< float*>(_v)); break; - case 59: _t->isoUfRate(*reinterpret_cast< float*>(_v)); break; - case 60: _t->isoUfRateActual(*reinterpret_cast< float*>(_v)); break; - case 61: _t->isoUfRateTarget(*reinterpret_cast< float*>(_v)); break; - case 62: _t->waterSampleTestResult(*reinterpret_cast< float*>(_v)); break; - case 63: _t->txCode(*reinterpret_cast< QString*>(_v)); break; - case 64: _t->notification(*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) { @@ -1398,29 +1380,29 @@ if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { - if (_id < 71) + if (_id < 70) qt_static_metacall(this, _c, _id, _a); - _id -= 71; + _id -= 70; } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) { - if (_id < 71) + if (_id < 70) *reinterpret_cast(_a[0]) = -1; - _id -= 71; + _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 -= 65; + _id -= 64; } else if (_c == QMetaObject::QueryPropertyDesignable) { - _id -= 65; + _id -= 64; } else if (_c == QMetaObject::QueryPropertyScriptable) { - _id -= 65; + _id -= 64; } else if (_c == QMetaObject::QueryPropertyStored) { - _id -= 65; + _id -= 64; } else if (_c == QMetaObject::QueryPropertyEditable) { - _id -= 65; + _id -= 64; } else if (_c == QMetaObject::QueryPropertyUser) { - _id -= 65; + _id -= 64; } #endif // QT_NO_PROPERTIES return _id; @@ -1441,451 +1423,444 @@ } // SIGNAL 2 -void View::VPostTreatmentAdjustmentTreatmentLog::secondaryPatientIDChanged(const QString & _t1) +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::bloodFlowRateChanged(const quint32 & _t1) +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::bloodFlowRateActualChanged(const quint32 & _t1) +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::dialysateFlowRateChanged(const quint32 & _t1) +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::dialysateFlowRateActualChanged(const quint32 & _t1) +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::treatmentDurationChanged(const quint32 & _t1) +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::treatmentDurationActualChanged(const quint32 & _t1) +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::acidConcentrateTypeChanged(const quint32 & _t1) +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::acidConcentrateTypeActualChanged(const quint32 & _t1) +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::bicarbonateCartridgeSizeChanged(const quint32 & _t1) +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::bicarbonateCartridgeSizeActualChanged(const quint32 & _t1) +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::potassiumConcentrationChanged(const quint32 & _t1) +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::potassiumConcentrationActualChanged(const quint32 & _t1) +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::calciumConcentrationChanged(const quint32 & _t1) +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::calciumConcentrationActualChanged(const quint32 & _t1) +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::bicarbonateConcentrationChanged(const quint32 & _t1) +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::bicarbonateConcentrationActualChanged(const quint32 & _t1) +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::sodiumConcentrationChanged(const quint32 & _t1) +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::sodiumConcentrationActualChanged(const quint32 & _t1) +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::vitalsIntervalChanged(const quint32 & _t1) +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::vitalsIntervalActualChanged(const quint32 & _t1) +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::dialyzerTypeChanged(const quint32 & _t1) +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::treatmentStartEpochChanged(const QString & _t1) +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::treatmentEndEpochChanged(const QString & _t1) +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::fluidBolusVolumeChanged(const quint32 & _t1) +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::fluidBolusVolumeActualChanged(const quint32 & _t1) +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::heparinTypeChanged(const quint32 & _t1) +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::heparinDeliveryDurationChanged(const quint32 & _t1) +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::heparinDeliveryDurationActualChanged(const quint32 & _t1) +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::treatmentModalityChanged(const quint32 & _t1) +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::treatmentModalityActualChanged(const quint32 & _t1) +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::hDFOperatingModeChanged(const quint32 & _t1) +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::hDFOperatingModeActualChanged(const quint32 & _t1) +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::hepatitisStatusChanged(const quint32 & _t1) +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::dialysateTemperatureChanged(const float & _t1) +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::dialysateTemperatureActualChanged(const float & _t1) +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::dialysateVolumeUsedChanged(const float & _t1) +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::heparinBolusVolumeChanged(const float & _t1) +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::heparinBolusVolumeActualChanged(const float & _t1) +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::heparinDispenseRateChanged(const float & _t1) +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::heparinDispenseRateActualChanged(const float & _t1) +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::heparinDeliveredVolumeChanged(const float & _t1) +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::uFVolumeChanged(const float & _t1) +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::uFVolumeActualChanged(const float & _t1) +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::uFVolumeTargetChanged(const float & _t1) +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::uFRateChanged(const float & _t1) +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::uFRateActualChanged(const float & _t1) +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::uFRateTargetChanged(const float & _t1) +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::substitutionVolumeChanged(const float & _t1) +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::substitutionVolumeActualChanged(const float & _t1) +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::substitutionVolumeTargetChanged(const float & _t1) +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::substitutionRateChanged(const float & _t1) +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::substitutionRateActualChanged(const float & _t1) +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::substitutionRateTargetChanged(const float & _t1) +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::isoUfVolumeChanged(const float & _t1) +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::isoUfVolumeActualChanged(const float & _t1) +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::isoUfVolumeTargetChanged(const float & _t1) +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::isoUfRateChanged(const float & _t1) +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::isoUfRateActualChanged(const float & _t1) +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::isoUfRateTargetChanged(const float & _t1) +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::waterSampleTestResultChanged(const float & _t1) +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::txCodeChanged(const QString & _t1) +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::notificationChanged(const QString & _t1) +void View::VPostTreatmentAdjustmentTreatmentLog::didAdjustment(const AdjustTreatmentLogRequestData & _t1) { void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; QMetaObject::activate(this, &staticMetaObject, 64, _a); } - -// SIGNAL 65 -void View::VPostTreatmentAdjustmentTreatmentLog::didAdjustment(const AdjustTreatmentLogRequestData & _t1) -{ - void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; - QMetaObject::activate(this, &staticMetaObject, 65, _a); -} QT_WARNING_POP QT_END_MOC_NAMESPACE