Fixed multiple issues with object write string

This commit is contained in:
Kyle Kiteveles 2023-08-15 14:27:05 -04:00
parent b87eb06a11
commit fd473c7ee8
6 changed files with 790 additions and 625 deletions

View file

@ -5,36 +5,38 @@ use derive_builder::Builder;
#[derive(Clone,Debug)]
pub enum FmCO2Species{
SpDATA
SpCALIBRATION
SpSTANDARD
SpMSG_ARGUMENTS
SpDATA,
SpCALIBRATION,
SpSTANDARD,
SpMSG_ARGUMENTS,
}
impl ObjectSpecies for FmCO2Species{}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CCO2DData{
Status:uint16,
ExtStatus:uint32,
Source:uint16,
Mode:uint8,
Method:uint8,
EtCO2:OBJECT,
FiCO2:OBJECT,
RR:OBJECT,
IPI:OBJECT,
S_EtCO2:OBJECT,
S_FiCO2:OBJECT,
ContCO2:OBJECT,
S_Density_5:OBJECT,
S_Density_10:OBJECT,
S_Density_30:OBJECT,
ApneaIndex_Total:OBJECT,
ApneaIndex_10_19:OBJECT,
ApneaIndex_20_29:OBJECT,
ApneaIndex_30:OBJECT,
DesatCount:OBJECT,
STime:TIME,
status:Status,
extstatus:ExtStatus,
source:Source,
mode:Mode,
method:Method,
etco2:OBJECT::CNumDStd,
fico2:OBJECT::CNumDStd,
rr:OBJECT::CNumDStd,
ipi:OBJECT::CNumDStd,
s_etco2:OBJECT::CNumDStd,
s_fico2:OBJECT::CNumDStd,
contco2:OBJECT::CNumDStd,
s_density_5:OBJECT::CNumDStd,
s_density_10:OBJECT::CNumDStd,
s_density_30:OBJECT::CNumDStd,
apneaindex_total:OBJECT::CNumDStd,
apneaindex_10_19:OBJECT::CNumDStd,
apneaindex_20_29:OBJECT::CNumDStd,
apneaindex_30:OBJECT::CNumDStd,
desatcount:OBJECT::CNumDStd,
stime:chrono::NativeDateTime,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -88,18 +90,23 @@ pub enum Method{
REMOTE,
}
pub impl CCO2DData {
fn new() -> Self { todo!() }
}
impl Object for CCO2DData{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmCO2 }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmCO2Species:CCO2DData) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmCO2Species::CCO2DData) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CCO2CCal{
Status:uint32,
Method:uint8,
GasConcentration:uint8,
status:Status,
method:Method,
gasconcentration:uint8,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -127,16 +134,21 @@ pub enum Method{
CALIBRATION_CHECK,
}
pub impl CCO2CCal {
fn new() -> Self { todo!() }
}
impl Object for CCO2CCal{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmCO2 }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnCONFIG }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmCO2Species:CCO2CCal) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmCO2Species::CCO2CCal) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CCO2CStd{
DisplayUnits:uint16,
displayunits:DisplayUnits,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -146,23 +158,31 @@ pub enum DisplayUnits{
UNITS_KPA,
}
pub impl CCO2CStd {
fn new() -> Self { todo!() }
}
impl Object for CCO2CStd{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmCO2 }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnCONFIG }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmCO2Species:CCO2CStd) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmCO2Species::CCO2CStd) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CCO2PMsgArg{
IOParameterA:uint16,
IOParameterB:uint16,
ioparametera:uint16,
ioparameterb:uint16,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CCO2PMsgArg {
fn new() -> Self { todo!() }
}
impl Object for CCO2PMsgArg{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmCO2 }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnPARAMETER }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmCO2Species:CCO2PMsgArg) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmCO2Species::CCO2PMsgArg) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}

View file

@ -5,89 +5,101 @@ use derive_builder::Builder;
#[derive(Clone,Debug)]
pub enum FmECGSpecies{
SpPACER
SpGLOBALMEASURE
SpLEADMEASURE
SpSTATUS
SpRHYTHMREPORT
SpAUTOREPORT
SpMISCELLANEOUS
SpSTANDARD
SpSETTINGS
SpSELECTOR
SpPACER,
SpGLOBALMEASURE,
SpLEADMEASURE,
SpSTATUS,
SpRHYTHMREPORT,
SpAUTOREPORT,
SpMISCELLANEOUS,
SpSTANDARD,
SpSETTINGS,
SpSELECTOR,
}
impl ObjectSpecies for FmECGSpecies{}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CECGDPacer{
CWaveSamplePacer:OBJECT,
CWaveDPacer:OBJECT,
CWaveCPacer:OBJECT,
cwavesamplepacer:OBJECT::CWaveSampleCRPDetect,
cwavedpacer:OBJECT::CWaveDStd,
cwavecpacer:OBJECT::CWaveCStd,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CECGDPacer {
fn new() -> Self { todo!() }
}
impl Object for CECGDPacer{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmECG }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmECGSpecies:CECGDPacer) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmECGSpecies::CECGDPacer) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CECGDGlobalMeas{
PDuration:uint32,
PQDuration:uint32,
QRSDuration:uint32,
QTDuration:uint32,
QTcDuration:uint32,
QTdDuration:uint32,
PAxis:uint32,
QRSAxis:uint32,
TAxis:uint32,
HeartRate:uint32,
POnset:uint32,
POffset:uint32,
QRSOnset:uint32,
QRSOffset:uint32,
TOffset:uint32,
pduration:uint32,
pqduration:uint32,
qrsduration:uint32,
qtduration:uint32,
qtcduration:uint32,
qtdduration:uint32,
paxis:uint32,
qrsaxis:uint32,
taxis:uint32,
heartrate:uint32,
ponset:uint32,
poffset:uint32,
qrsonset:uint32,
qrsoffset:uint32,
toffset:uint32,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CECGDGlobalMeas {
fn new() -> Self { todo!() }
}
impl Object for CECGDGlobalMeas{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmECG }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmECGSpecies:CECGDGlobalMeas) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmECGSpecies::CECGDGlobalMeas) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CECGDLeadMeas{
LeadIdentifier:uint16,
PposAmp:int32,
PnegAmp:int32,
QDuration:int32,
QAmp:int32,
RDuration:int32,
RAmp:int32,
SDuration:int32,
SAmp:int32,
RAccDuration:int32,
RAccAmp:int32,
SAccDuration:int32,
SAccAmp:int32,
IDuration:int32,
ST0:int32,
ST20:int32,
ST40:int32,
ST60:int32,
ST80:int32,
TposAmp:int32,
TnegAmp:int32,
R2AccDuration:int32,
R2AccAmp:int32,
S2AccDuration:int32,
S2AccAmp:int32,
KDuration:int32,
EndT:int32,
QrsType:widechar,
leadidentifier:LeadIdentifier,
pposamp:int32,
pnegamp:int32,
qduration:int32,
qamp:int32,
rduration:int32,
ramp:int32,
sduration:int32,
samp:int32,
raccduration:int32,
raccamp:int32,
saccduration:int32,
saccamp:int32,
iduration:int32,
st0:int32,
st20:int32,
st40:int32,
st60:int32,
st80:int32,
tposamp:int32,
tnegamp:int32,
r2accduration:int32,
r2accamp:int32,
s2accduration:int32,
s2accamp:int32,
kduration:int32,
endt:int32,
qrstype:widechar,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -118,19 +130,24 @@ pub enum LeadIdentifier{
NONE,
}
pub impl CECGDLeadMeas {
fn new() -> Self { todo!() }
}
impl Object for CECGDLeadMeas{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmECG }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmECGSpecies:CECGDLeadMeas) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmECGSpecies::CECGDLeadMeas) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CECGDStatus{
ElectrodeOffStatus:uint32,
ArrhythmiaStatus:byte,
ActiveLeads:uint32,
Container:OBJECT,
electrodeoffstatus:ElectrodeOffStatus,
arrhythmiastatus:byte,
activeleads:ActiveLeads,
container:OBJECT::ANY_CLASS,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -167,19 +184,24 @@ pub enum ActiveLeads{
ECG_V6,
}
pub impl CECGDStatus {
fn new() -> Self { todo!() }
}
impl Object for CECGDStatus{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmECG }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmECGSpecies:CECGDStatus) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmECGSpecies::CECGDStatus) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CECGCRhythmReport{
LeadArrangement:uint16,
DefSpeedSetting:uint16,
StdLeadOrder:uint8,
AugLeadOrder:uint8,
leadarrangement:LeadArrangement,
defspeedsetting:DefSpeedSetting,
stdleadorder:uint8,
augleadorder:uint8,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -198,45 +220,50 @@ pub enum DefSpeedSetting{
50mm_s,
}
pub impl CECGCRhythmReport {
fn new() -> Self { todo!() }
}
impl Object for CECGCRhythmReport{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmECG }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnCONFIG }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmECGSpecies:CECGCRhythmReport) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmECGSpecies::CECGCRhythmReport) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CECGCAutoReport{
ExtMeasurements:boolean,
Interp:boolean,
CopiesWithInt:boolean,
UnconfReport:boolean,
AbnormalEcg:boolean,
FName:boolean,
SLName:boolean,
MI:boolean,
Wt:boolean,
Ht:boolean,
Gender:boolean,
Race:boolean,
Med:boolean,
ClinicalHist:boolean,
BP:boolean,
Comments:boolean,
CustDef1:boolean,
CustDef2:boolean,
ReasonStatementsEnabled:boolean,
AgeFormat:uint16,
LeadArrangement:uint16,
RhythLd1:uint16,
RhythLd2:uint16,
RhythLd3:uint16,
AvgCycle:uint16,
Copies:uint16,
CustDef1Lbl:widechar,
CustDef2Lbl:widechar,
Physician:boolean,
Technician:boolean,
extmeasurements:boolean,
interp:boolean,
copieswithint:boolean,
unconfreport:boolean,
abnormalecg:boolean,
fname:boolean,
slname:boolean,
mi:boolean,
wt:boolean,
ht:boolean,
gender:boolean,
race:boolean,
med:boolean,
clinicalhist:boolean,
bp:boolean,
comments:boolean,
custdef1:boolean,
custdef2:boolean,
reasonstatementsenabled:boolean,
ageformat:AgeFormat,
leadarrangement:LeadArrangement,
rhythld1:RhythLd1,
rhythld2:RhythLd2,
rhythld3:RhythLd3,
avgcycle:AvgCycle,
copies:uint16,
custdef1lbl:widechar,
custdef2lbl:widechar,
physician:boolean,
technician:boolean,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -368,37 +395,42 @@ pub enum AvgCycle{
6x2_1R,
}
pub impl CECGCAutoReport {
fn new() -> Self { todo!() }
}
impl Object for CECGCAutoReport{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmECG }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnCONFIG }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmECGSpecies:CECGCAutoReport) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmECGSpecies::CECGCAutoReport) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CECGCMiscellaneous{
LeadConfig:uint16,
Mains:uint16,
AutoExport:uint16,
ElectrodeLbl:uint16,
LeadTiming:uint16,
DefGainSetting:uint16,
DefMuscleFilter:boolean,
DefBaselineFilter:boolean,
BaselineCenter:boolean,
Autosave:boolean,
AutoReport2:boolean,
PrintArtifactReport:boolean,
ElectrodePlacement:uint16,
QTcMethod:uint16,
SaveReminder:boolean,
DisableMains:boolean,
ECGAutoPrint:boolean,
ECGSetPatientDemographic:boolean,
RemoteFolderPath:widechar,
QRSTone:uint16,
PrintLabel:uint16,
PacerLead:uint16,
leadconfig:LeadConfig,
mains:Mains,
autoexport:AutoExport,
electrodelbl:ElectrodeLbl,
leadtiming:LeadTiming,
defgainsetting:DefGainSetting,
defmusclefilter:boolean,
defbaselinefilter:boolean,
baselinecenter:boolean,
autosave:boolean,
autoreport2:boolean,
printartifactreport:boolean,
electrodeplacement:ElectrodePlacement,
qtcmethod:QTcMethod,
savereminder:boolean,
disablemains:boolean,
ecgautoprint:boolean,
ecgsetpatientdemographic:boolean,
remotefolderpath:widechar,
qrstone:QRSTone,
printlabel:PrintLabel,
pacerlead:PacerLead,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -512,22 +544,27 @@ pub enum PacerLead{
V6R,
}
pub impl CECGCMiscellaneous {
fn new() -> Self { todo!() }
}
impl Object for CECGCMiscellaneous{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmECG }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnCONFIG }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmECGSpecies:CECGCMiscellaneous) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmECGSpecies::CECGCMiscellaneous) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CECGCSettings{
ActiveLeads:uint32,
MainsFilter:uint8,
PacerEnabled:boolean,
LeadMode:uint8,
VTachThreshold:uint8,
ImpedanceRespiration:boolean,
AsystoleThreshold:uint16,
activeleads:ActiveLeads,
mainsfilter:MainsFilter,
pacerenabled:boolean,
leadmode:LeadMode,
vtachthreshold:uint8,
impedancerespiration:boolean,
asystolethreshold:uint16,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -566,22 +603,30 @@ pub enum LeadMode{
5_LEAD,
}
pub impl CECGCSettings {
fn new() -> Self { todo!() }
}
impl Object for CECGCSettings{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmECG }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnCONFIG }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmECGSpecies:CECGCSettings) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmECGSpecies::CECGCSettings) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CECGPSelector{
SpeciesSelector:uint32,
speciesselector:uint32,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CECGPSelector {
fn new() -> Self { todo!() }
}
impl Object for CECGPSelector{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmECG }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnPARAMETER }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmECGSpecies:CECGPSelector) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmECGSpecies::CECGPSelector) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}

View file

@ -21,18 +21,20 @@ pub enum FmNIBPSpecies{
}
impl ObjectSpecies for FmNIBPSpecies{}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CNIBPDStd{
STime:TIME,
Status:uint16,
Systolic:int16,
Diastolic:int16,
MAP:int16,
HR:uint16,
ExtStatus:uint16,
Source:uint16,
Mode:uint8,
Method:uint8,
stime:chrono::NativeDateTime,
status:Status,
systolic:int16,
diastolic:int16,
map:int16,
hr:uint16,
extstatus:ExtStatus,
source:Source,
mode:Mode,
method:Method,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -43,16 +45,12 @@ pub enum Status{
DATA_FAILURE,
DATA_EXCEPTION,
DATA_PROCESSING,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
pub enum ExtStatus{
#[default]
NONE,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -65,8 +63,6 @@ pub enum Source{
MODF,
POEM,
MODG,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -77,8 +73,6 @@ pub enum Mode{
ADULT,
NEONATAL,
PEDIATRIC,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -94,24 +88,27 @@ pub enum Method{
NEONATAL_STEP_BP,
LINEAR_DEFLATION_BP,
AVERAGE_BP,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CNIBPDStd {
fn new() -> Self { todo!() }
}
impl Object for CNIBPDStd{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies:CNIBPDStd) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies::CNIBPDStd) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CNIBPDData{
Status:int16,
Systolic:OBJECT::CNumDStd,
Diastolic:OBJECT::CNumDStd,
MAP:OBJECT::CNumDStd,
PR:OBJECT::CNumDStd,
status:Status,
systolic:OBJECT::CNumDStd,
diastolic:OBJECT::CNumDStd,
map:OBJECT::CNumDStd,
pr:OBJECT::CNumDStd,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -133,36 +130,44 @@ pub enum Status{
RD_LEAK,
RD_SAFETY_FAULT,
RD_ZERO_FAULT,
}
pub impl CNIBPDData {
fn new() -> Self { todo!() }
}
impl Object for CNIBPDData{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies::CNIBPDData) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone,Debug)]
pub struct CNIBPDChunk{
tag:int8,
chunkid:uint16,
chunkindex:uint16,
chunkdata:uint8,
#[getter(skip)]
raw_object:RawObject,
}
impl Object for CNIBPDData{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies:CNIBPDData) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
pub impl CNIBPDChunk {
fn new() -> Self { todo!() }
}
#[derive(Getters,Builder,Clone)]
pub struct CNIBPDChunk{
tag:int8,
chunkId:uint16,
chunkIndex:uint16,
chunkData:uint8,
}
impl Object for CNIBPDChunk{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies:CNIBPDChunk) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies::CNIBPDChunk) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CNIBPDHState{
hardware:int16,
hardware:hardware,
state:int16,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -171,21 +176,24 @@ pub enum hardware{
PRIM_VALVE,
SEC_VALVE,
PUMP,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CNIBPDHState {
fn new() -> Self { todo!() }
}
impl Object for CNIBPDHState{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies:CNIBPDHState) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies::CNIBPDHState) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CNIBPDLock{
lock:int16,
lock:lock,
state:int8,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -197,65 +205,78 @@ pub enum lock{
SINGLE_LUMEN_CHECK,
AD_CHANNEL,
FAILSAFE_TEST_MODE,
}
pub impl CNIBPDLock {
fn new() -> Self { todo!() }
}
impl Object for CNIBPDLock{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies::CNIBPDLock) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone,Debug)]
pub struct CNIBPDRData{
raw5v:uint32,
raw1v:uint32,
raw2v:uint32,
raw4v:uint32,
rawbat:int16,
rawambtemp:uint32,
rawprimtrans:uint32,
rawsectrans:int16,
rawsecbat:int16,
rawseccorr:int16,
#[getter(skip)]
raw_object:RawObject,
}
impl Object for CNIBPDLock{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies:CNIBPDLock) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
pub impl CNIBPDRData {
fn new() -> Self { todo!() }
}
#[derive(Getters,Builder,Clone)]
pub struct CNIBPDRData{
raw5V:uint32,
raw1V:uint32,
raw2V:uint32,
raw4V:uint32,
rawBat:int16,
rawAmbTemp:uint32,
rawPrimTrans:uint32,
rawSecTrans:int16,
rawSecBat:int16,
rawSecCorr:int16,
}
impl Object for CNIBPDRData{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies:CNIBPDRData) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies::CNIBPDRData) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CNIBPDPData{
primPress:int16,
primPressNoise:int16,
primAzeroOffset:int16,
secPress:int16,
secPressNoise:int16,
secAzeroOffset:int16,
primpress:int16,
primpressnoise:int16,
primazerooffset:int16,
secpress:int16,
secpressnoise:int16,
secazerooffset:int16,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CNIBPDPData {
fn new() -> Self { todo!() }
}
impl Object for CNIBPDPData{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies:CNIBPDPData) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies::CNIBPDPData) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CNIBPDStatus{
moduleState:uint16,
modulestate:moduleState,
error:uint16,
hardwareStates:uint16,
safetyStates:uint16,
cuffPressure:int16,
batVoltage:int16,
ambTemp:int16,
statusType:int16,
hardwarestates:uint16,
safetystates:safetyStates,
cuffpressure:int16,
batvoltage:int16,
ambtemp:int16,
statustype:statusType,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -271,8 +292,6 @@ pub enum moduleState{
ERROR,
BOOT,
POST,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -284,8 +303,6 @@ pub enum safetyStates{
failsafeFault,
autoZeroFault,
transducerFault,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -294,28 +311,31 @@ pub enum statusType{
NONE,
PRIMARY,
SECONDARY,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CNIBPDStatus {
fn new() -> Self { todo!() }
}
impl Object for CNIBPDStatus{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies:CNIBPDStatus) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies::CNIBPDStatus) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CNIBPDDataModified{
NIBPData:OBJECT::CNIBPDData,
Status:uint16,
STime:TIME,
Mode:uint8,
PatientPosition:uint16,
CuffSize:uint16,
CuffLocation:uint16,
Source:uint16,
Method:uint8,
nibpdata:OBJECT::CNIBPDData,
status:Status,
stime:chrono::NativeDateTime,
mode:Mode,
patientposition:PatientPosition,
cuffsize:CuffSize,
cufflocation:CuffLocation,
source:Source,
method:Method,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -326,8 +346,6 @@ pub enum Status{
DATA_FAILURE,
DATA_EXCEPTION,
DATA_PROCESSING,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -338,8 +356,6 @@ pub enum Mode{
ADULT,
NEONATAL,
PEDIATRIC,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -350,8 +366,6 @@ pub enum PatientPosition{
LYING,
SITTING,
STANDING,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -374,8 +388,6 @@ pub enum CuffSize{
LARGE_ADULT,
LARGE_ADULT_LONG,
THIGH,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -387,8 +399,6 @@ pub enum CuffLocation{
RIGHT_ARM,
LEFT_LEG,
RIGHT_LEG,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -401,8 +411,6 @@ pub enum Source{
MODF,
POEM,
MODG,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -418,21 +426,24 @@ pub enum Method{
NEONATAL_STEP_BP,
LINEAR_DEFLATION_BP,
AVERAGE_BP,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CNIBPDDataModified {
fn new() -> Self { todo!() }
}
impl Object for CNIBPDDataModified{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies:CNIBPDDataModified) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies::CNIBPDDataModified) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CNIBPCStd{
DisplayUnits:uint16,
MAPDisplay:boolean,
displayunits:DisplayUnits,
mapdisplay:MAPDisplay,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -440,8 +451,6 @@ pub enum DisplayUnits{
#[default]
NIBP_MMHG,
NIBP_KPA,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -449,29 +458,32 @@ pub enum MAPDisplay{
#[default]
DISABLE,
ENABLE,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CNIBPCStd {
fn new() -> Self { todo!() }
}
impl Object for CNIBPCStd{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnCONFIG }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies:CNIBPCStd) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies::CNIBPCStd) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CNIBPCData{
dfltAdultTargPress:int16,
dfltPedTargPress:int16,
dfltNeoTargPress:int16,
pedMaxPressLimit:int16,
residualMaxPressLimit:int16,
dfltPatientMode:int8,
dfltAdultAlg:int8,
dfltPedAlg:int8,
dfltNeoAlg:int8,
SAOEnabled:boolean,
dfltadulttargpress:int16,
dfltpedtargpress:int16,
dfltneotargpress:int16,
pedmaxpresslimit:int16,
residualmaxpresslimit:int16,
dfltpatientmode:dfltPatientMode,
dfltadultalg:int8,
dfltpedalg:int8,
dfltneoalg:int8,
saoenabled:boolean,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -480,27 +492,30 @@ pub enum dfltPatientMode{
ADULT,
PEDIATRIC,
NEONATE,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CNIBPCData {
fn new() -> Self { todo!() }
}
impl Object for CNIBPCData{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnCONFIG }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies:CNIBPCData) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies::CNIBPCData) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CNIBPCCal{
calType:uint8,
calSignature:int32,
calDateTime:TIME,
modConfig:int16,
spanCorr:int16,
zeroCorr:int16,
battCal:int16,
tempCal:int16,
caltype:calType,
calsignature:int32,
caldatetime:chrono::NativeDateTime,
modconfig:int16,
spancorr:int16,
zerocorr:int16,
battcal:int16,
tempcal:int16,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -509,25 +524,28 @@ pub enum calType{
NONE,
PRIMARY,
SECONDARY,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CNIBPCCal {
fn new() -> Self { todo!() }
}
impl Object for CNIBPCCal{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnCONFIG }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies:CNIBPCCal) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies::CNIBPCCal) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CNIBPPData{
targPress:int16,
patientMode:int8,
cycleMode:int8,
algorithm:int8,
disableNeoCheck:int8,
firstReading:boolean,
targpress:int16,
patientmode:patientMode,
cyclemode:cycleMode,
algorithm:algorithm,
disableneocheck:int8,
firstreading:boolean,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -537,8 +555,6 @@ pub enum patientMode{
ADULT,
PEDIATRIC,
NEONATE,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -547,8 +563,6 @@ pub enum cycleMode{
MANUAL,
LONG_AUTO,
STAT,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -558,51 +572,67 @@ pub enum algorithm{
FAST_BP,
STEP_BP,
NEO_BP,
}
pub impl CNIBPPData {
fn new() -> Self { todo!() }
}
impl Object for CNIBPPData{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnPARAMETER }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies::CNIBPPData) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone,Debug)]
pub struct CNIBPPSelector{
value:uint32,
#[getter(skip)]
raw_object:RawObject,
}
impl Object for CNIBPPData{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnPARAMETER }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies:CNIBPPData) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
pub impl CNIBPPSelector {
fn new() -> Self { todo!() }
}
#[derive(Getters,Builder,Clone)]
pub struct CNIBPPSelector{
Value:uint32,
}
impl Object for CNIBPPSelector{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnPARAMETER }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies:CNIBPPSelector) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies::CNIBPPSelector) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CNIBPPChunkSelector{
chunk:uint32,
index:uint32,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CNIBPPChunkSelector {
fn new() -> Self { todo!() }
}
impl Object for CNIBPPChunkSelector{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnPARAMETER }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies:CNIBPPChunkSelector) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies::CNIBPPChunkSelector) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CNIBPDExtStd{
Container:OBJECT::ANY_CLASS,
container:OBJECT::ANY_CLASS,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CNIBPDExtStd {
fn new() -> Self { todo!() }
}
impl Object for CNIBPDExtStd{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmNIBP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATAEXT }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies:CNIBPDExtStd) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmNIBPSpecies::CNIBPDExtStd) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}

View file

@ -5,23 +5,25 @@ use derive_builder::Builder;
#[derive(Clone,Debug)]
pub enum FmSPO2Species{
SpSTANDARD
SpDATA
SpDATAMODIFIED
SpSELECTOR
SpSTANDARD,
SpDATA,
SpDATAMODIFIED,
SpSELECTOR,
}
impl ObjectSpecies for FmSPO2Species{}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CSpO2DStd{
STime:TIME,
Status:uint16,
Sat:uint16,
HR:uint16,
ExtStatus:uint16,
Source:uint16,
Mode:uint8,
Method:uint8,
stime:chrono::NativeDateTime,
status:Status,
sat:uint16,
hr:uint16,
extstatus:ExtStatus,
source:Source,
mode:Mode,
method:Method,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -81,31 +83,36 @@ pub enum Method{
REMOTE,
}
pub impl CSpO2DStd {
fn new() -> Self { todo!() }
}
impl Object for CSpO2DStd{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmSPO2 }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmSPO2Species:CSpO2DStd) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmSPO2Species::CSpO2DStd) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CSpO2DData{
STime:TIME,
ExtStatus:uint16,
Source:uint16,
Sat:OBJECT,
HR:OBJECT,
PI:OBJECT,
Status:uint16,
ElapsedSatSeconds:OBJECT,
TotalSatSeconds:OBJECT,
SatConfidence:OBJECT,
HRConfidence:OBJECT,
PIConfidence:OBJECT,
PVIConfidence:OBJECT,
PVI:OBJECT,
Mode:uint8,
Method:uint8,
stime:chrono::NativeDateTime,
extstatus:ExtStatus,
source:Source,
sat:OBJECT::CNumDStd,
hr:OBJECT::CNumDStd,
pi:OBJECT::CNumDStd,
status:Status,
elapsedsatseconds:OBJECT::CNumDStd,
totalsatseconds:OBJECT::CNumDStd,
satconfidence:OBJECT::CNumDStd,
hrconfidence:OBJECT::CNumDStd,
piconfidence:OBJECT::CNumDStd,
pviconfidence:OBJECT::CNumDStd,
pvi:OBJECT::CNumDStd,
mode:Mode,
method:Method,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -169,20 +176,25 @@ pub enum Method{
REMOTE,
}
pub impl CSpO2DData {
fn new() -> Self { todo!() }
}
impl Object for CSpO2DData{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmSPO2 }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmSPO2Species:CSpO2DData) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmSPO2Species::CSpO2DData) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CSpO2DDataModified{
SpO2Data:OBJECT,
O2FlowRate:uint8,
O2Concentration:uint8,
O2Method:uint8,
Location:uint8,
spo2data:OBJECT::CSpO2DData,
o2flowrate:uint8,
o2concentration:uint8,
o2method:O2Method,
location:Location,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -215,17 +227,22 @@ pub enum Location{
FOREHEAD,
}
pub impl CSpO2DDataModified {
fn new() -> Self { todo!() }
}
impl Object for CSpO2DDataModified{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmSPO2 }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmSPO2Species:CSpO2DDataModified) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmSPO2Species::CSpO2DDataModified) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CSpO2CStd{
Enabled:boolean,
InstalledModule:uint16,
enabled:boolean,
installedmodule:InstalledModule,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -245,25 +262,30 @@ pub enum InstalledModule{
NELLCOR_PMB05N,
}
pub impl CSpO2CStd {
fn new() -> Self { todo!() }
}
impl Object for CSpO2CStd{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmSPO2 }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnCONFIG }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmSPO2Species:CSpO2CStd) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmSPO2Species::CSpO2CStd) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CSpO2CData{
SatExponent:int8,
PIExponent:int8,
SatAlarms:OBJECT,
HRAlarms:OBJECT,
FastSat:uint8,
Sensitivity:uint8,
AveragingTime:uint8,
SatSecondsLimit:uint8,
SmartTone:uint8,
PVIExponent:int8,
satexponent:int8,
piexponent:int8,
satalarms:OBJECT::CNumCStd,
hralarms:OBJECT::CNumCStd,
fastsat:FastSat,
sensitivity:Sensitivity,
averagingtime:AveragingTime,
satsecondslimit:SatSecondsLimit,
smarttone:SmartTone,
pviexponent:int8,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -315,22 +337,30 @@ pub enum SmartTone{
ON,
}
pub impl CSpO2CData {
fn new() -> Self { todo!() }
}
impl Object for CSpO2CData{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmSPO2 }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnCONFIG }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmSPO2Species:CSpO2CData) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmSPO2Species::CSpO2CData) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CSpO2PSelector{
Value:uint32,
value:uint32,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CSpO2PSelector {
fn new() -> Self { todo!() }
}
impl Object for CSpO2PSelector{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmSPO2 }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnPARAMETER }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmSPO2Species:CSpO2PSelector) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmSPO2Species::CSpO2PSelector) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}

View file

@ -22,15 +22,17 @@ pub enum FmTEMPSpecies{
}
impl ObjectSpecies for FmTEMPSpecies{}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CTempDStd{
STime:TIME,
Status:uint16,
ExtStatus:uint16,
Source:uint16,
Mode:uint8,
Method:uint8,
Temperature:float,
stime:chrono::NativeDateTime,
status:Status,
extstatus:ExtStatus,
source:Source,
mode:Mode,
method:Method,
temperature:float,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -41,8 +43,6 @@ pub enum Status{
DATA_FAILURE,
DATA_EXCEPTION,
DATA_PROCESSING,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -73,8 +73,6 @@ pub enum ExtStatus{
PREMATURE_BUTTON_PRESS,
CALIBRATION,
UNADJUSTED_NO_OFFSETS,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -87,8 +85,6 @@ pub enum Source{
SURETEMP_PLUS,
BRAUN_PRO4000,
BRAUN_PRO6000,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -102,8 +98,6 @@ pub enum Mode{
CAL_KEY,
ADULT_AXIL,
TYMPANIC,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -119,26 +113,29 @@ pub enum Method{
IR,
BRAUN_CALC,
TECHNIQUE_COMPENSATION_CALC,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CTempDStd {
fn new() -> Self { todo!() }
}
impl Object for CTempDStd{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies:CTempDStd) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CTempDStd) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CTempDData{
STime:TIME,
Status:uint16,
ExtStatus:uint16,
Source:uint16,
Mode:uint8,
Method:uint8,
Temperature:OBJECT::CNumDFloat,
stime:chrono::NativeDateTime,
status:Status,
extstatus:ExtStatus,
source:Source,
mode:Mode,
method:Method,
temperature:OBJECT::CNumDFloat,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -149,8 +146,6 @@ pub enum Status{
DATA_FAILURE,
DATA_EXCEPTION,
DATA_PROCESSING,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -181,8 +176,6 @@ pub enum ExtStatus{
PREMATURE_BUTTON_PRESS,
CALIBRATION,
UNADJUSTED_NO_OFFSETS,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -195,8 +188,6 @@ pub enum Source{
SURETEMP_PLUS,
BRAUN_PRO4000,
BRAUN_PRO6000,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -210,8 +201,6 @@ pub enum Mode{
CAL_KEY,
ADULT_AXIL,
TYMPANIC,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -227,29 +216,30 @@ pub enum Method{
IR,
BRAUN_CALC,
TECHNIQUE_COMPENSATION_CALC,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CTempDData {
fn new() -> Self { todo!() }
}
impl Object for CTempDData{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies:CTempDData) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CTempDData) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CSTPTempDEng{
temp:float,
probe_temp:float,
heater:uint16,
reserved_1:uint16,
method:uint16,
algo:uint16,
status:uint16,
error:uint16,
method:method,
algo:algo,
status:status,
error:error,
active:uint8,
probe_type:uint16,
probe_type:probe_type,
resistance:float,
ambient_temp:float,
ptb_resistance:float,
@ -258,6 +248,8 @@ pub struct CSTPTempDEng{
probe_temp_max:float,
complete:uint8,
sample:uint32,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -266,8 +258,6 @@ pub enum method{
PREDICT,
MONITOR,
CLINICAL,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -278,8 +268,6 @@ pub enum algo{
PED_AX_ALG,
ADULT_AX_ALG,
RECTAL_ALG,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -300,8 +288,6 @@ pub enum status{
NO_PREDICT,
ERROR,
MONITOR,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -343,8 +329,6 @@ pub enum error{
ERROR_NO_PROBE_WELL,
ERROR_POST_FAIL,
ERROR_INTERNAL_FAULT,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -354,40 +338,43 @@ pub enum probe_type{
ORAL,
RECTAL,
CALKEY,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CSTPTempDEng {
fn new() -> Self { todo!() }
}
impl Object for CSTPTempDEng{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies:CSTPTempDEng) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPTempDEng) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CSTPDProbe{
probeType:int8,
partNumber:int8,
lotCode:uint32,
lotSeqNum:int16,
probeArrayLoc:int16,
testPassFailCode:int16,
calSignature:int32,
calDateTime:TIME,
heaterGain:float,
heaterTimeDelay:float,
probetype:probeType,
partnumber:int8,
lotcode:uint32,
lotseqnum:int16,
probearrayloc:int16,
testpassfailcode:int16,
calsignature:int32,
caldatetime:chrono::NativeDateTime,
heatergain:float,
heatertimedelay:float,
responses:float,
thermCalM:float,
thermCalB:float,
coefA:float,
coefB:float,
coefC:float,
coefD:float,
coefE:float,
probeCycleCount:uint32,
deviceCount:uint16,
lastDeviceSN:int8,
thermcalm:float,
thermcalb:float,
coefa:float,
coefb:float,
coefc:float,
coefd:float,
coefe:float,
probecyclecount:uint32,
devicecount:uint16,
lastdevicesn:int8,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -397,21 +384,24 @@ pub enum probeType{
CALKEY,
RECTAL,
NONE,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CSTPDProbe {
fn new() -> Self { todo!() }
}
impl Object for CSTPDProbe{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies:CSTPDProbe) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPDProbe) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CSTPDHState{
hardware:int16,
hardware:hardware,
state:int16,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -420,21 +410,24 @@ pub enum hardware{
PROBE_WELL_SW,
PROBE_SW,
PROBE_CONNECTED_SW,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CSTPDHState {
fn new() -> Self { todo!() }
}
impl Object for CSTPDHState{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies:CSTPDHState) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPDHState) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CSTPDLock{
lock:int16,
lock:lock,
state:int8,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -442,43 +435,51 @@ pub enum lock{
#[default]
DIGITAL_INPUT_LOCK,
AD_CHANNEL,
}
pub impl CSTPDLock {
fn new() -> Self { todo!() }
}
impl Object for CSTPDLock{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPDLock) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone,Debug)]
pub struct CSTPDRData{
thermistor:uint32,
ptbresistor:uint32,
rcalresistor:uint32,
vref:uint32,
#[getter(skip)]
raw_object:RawObject,
}
impl Object for CSTPDLock{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies:CSTPDLock) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
pub impl CSTPDRData {
fn new() -> Self { todo!() }
}
#[derive(Getters,Builder,Clone)]
pub struct CSTPDRData{
thermistor:uint32,
PTBResistor:uint32,
rCalResistor:uint32,
vRef:uint32,
}
impl Object for CSTPDRData{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies:CSTPDRData) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPDRData) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CSTPDStat{
state:uint16,
error:uint16,
hardwareState:uint16,
finalTemp:float,
probeTemp:float,
method:uint16,
probeType:uint16,
algorithm:uint16,
state:state,
error:error,
hardwarestate:hardwareState,
finaltemp:float,
probetemp:float,
method:method,
probetype:probeType,
algorithm:algorithm,
battery:uint16,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -499,8 +500,6 @@ pub enum state{
NO_PREDICT,
ERROR,
MONITOR,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -542,8 +541,6 @@ pub enum error{
ERROR_NO_PROBE_WELL,
ERROR_POST_FAIL,
ERROR_INTERNAL_FAULT,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -555,8 +552,6 @@ pub enum hardwareState{
savingCal,
savingSettings,
takeReadingActive,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -565,8 +560,6 @@ pub enum method{
PREDICT,
MONITOR,
CLINICAL,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -576,8 +569,6 @@ pub enum probeType{
ORAL,
RECTAL,
CALKEY,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -588,18 +579,19 @@ pub enum algorithm{
PED_AX_ALG,
ADULT_AX_ALG,
RECTAL_ALG,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CSTPDStat {
fn new() -> Self { todo!() }
}
impl Object for CSTPDStat{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies:CSTPDStat) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPDStat) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CSTPDSample{
channel:uint8,
error:uint8,
@ -608,26 +600,33 @@ pub struct CSTPDSample{
temperature:float,
resistance:float,
last_rcal:uint32,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CSTPDSample {
fn new() -> Self { todo!() }
}
impl Object for CSTPDSample{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies:CSTPDSample) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPDSample) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CTempDTouch{
ele0:uint16,
ele1:uint16,
ele2:uint16,
touchStatus:uint16,
touchstatus:uint16,
ele0bv:uint8,
ele1bv:uint8,
ele2bv:uint8,
hardwareStateIR:uint16,
sampleCount:uint32,
hardwarestateir:hardwareStateIR,
samplecount:uint32,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -635,31 +634,34 @@ pub enum hardwareStateIR{
#[default]
TAKE_READING_ACTIVE,
PROBE_COVER_ON,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CTempDTouch {
fn new() -> Self { todo!() }
}
impl Object for CTempDTouch{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies:CTempDTouch) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CTempDTouch) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CTempDTherm{
ambient:float,
ambient_count:int32,
thermopile:float,
thermopile_count:int32,
sampleCount:uint32,
heaterPWM:int16,
heaterState:int16,
heaterError:int16,
samplecount:uint32,
heaterpwm:int16,
heaterstate:heaterState,
heatererror:int16,
braun_ambient:float,
TCValue:float,
tcvalue:float,
pre_num:uint8,
post_num:uint8,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -670,23 +672,26 @@ pub enum heaterState{
HEATER_ON,
READY,
ERROR,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CTempDTherm {
fn new() -> Self { todo!() }
}
impl Object for CTempDTherm{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies:CTempDTherm) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CTempDTherm) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CTempCStd{
Enabled:boolean,
InstalledModule:uint16,
DisplayUnits:uint16,
Mode:uint16,
enabled:boolean,
installedmodule:InstalledModule,
displayunits:DisplayUnits,
mode:Mode,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -699,8 +704,6 @@ pub enum InstalledModule{
SURETEMP_PLUS,
BRAUN_PRO4000,
BRAUN_PRO6000,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -708,8 +711,6 @@ pub enum DisplayUnits{
#[default]
DEG_F,
DEG_C,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -721,23 +722,26 @@ pub enum Mode{
ADULT_AXIL,
PED_AXIL,
LAST,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CTempCStd {
fn new() -> Self { todo!() }
}
impl Object for CTempCStd{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnCONFIG }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies:CTempCStd) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CTempCStd) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CSTPCStd{
clinicalPause:uint16,
deviceType:uint8,
dfltAlgorithm:uint8,
ambientBias:float,
clinicalpause:uint16,
devicetype:deviceType,
dfltalgorithm:dfltAlgorithm,
ambientbias:float,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -745,8 +749,6 @@ pub enum deviceType{
#[default]
PREDICT_DEVICE,
MONITOR_DEVICE,
#[getter(skip)]
raw_object:RawObject,
}
#[derive(Clone,Copy,Debug,Default)]
@ -756,58 +758,74 @@ pub enum dfltAlgorithm{
PED_AXILLARY,
ADULT_AXILLARY,
LAST,
}
pub impl CSTPCStd {
fn new() -> Self { todo!() }
}
impl Object for CSTPCStd{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnCONFIG }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPCStd) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone,Debug)]
pub struct CSTPCCal{
signature:uint32,
datetime:chrono::NativeDateTime,
modconfig:float,
yp0:float,
rp0:float,
rptbeff:float,
rcaleff:float,
vref:float,
#[getter(skip)]
raw_object:RawObject,
}
impl Object for CSTPCStd{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnCONFIG }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies:CSTPCStd) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
pub impl CSTPCCal {
fn new() -> Self { todo!() }
}
#[derive(Getters,Builder,Clone)]
pub struct CSTPCCal{
signature:uint32,
dateTime:TIME,
modConfig:float,
Yp0:float,
Rp0:float,
RPTBEff:float,
RCalEff:float,
vRef:float,
}
impl Object for CSTPCCal{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnCONFIG }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies:CSTPCCal) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPCCal) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CTempPMsgArg{
IOParameterA:uint32,
IOParameterB:uint32,
ioparametera:uint32,
ioparameterb:uint32,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CTempPMsgArg {
fn new() -> Self { todo!() }
}
impl Object for CTempPMsgArg{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnPARAMETER }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies:CTempPMsgArg) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CTempPMsgArg) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}
#[derive(Getters,Builder,Clone)]
#[derive(Getters,Builder,Clone,Debug)]
pub struct CSTPPSelector{
Value:uint32,
value:uint32,
#[getter(skip)]
raw_object:RawObject,
}
pub impl CSTPPSelector {
fn new() -> Self { todo!() }
}
impl Object for CSTPPSelector{
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnPARAMETER }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies:CSTPPSelector) }
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPPSelector) }
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
}

View file

@ -238,28 +238,48 @@ fn output_gen(family: oop::Family, output_path: String) -> (String, String){
write_string = format!(
"{}{}{}{}",
write_string,
"#[derive(Getters,Builder,Clone)]\npub struct ",
"#[derive(Getters,Builder,Clone,Debug)]\npub struct ",
object.get_name(),
"{\n"
);
let mut enums = Vec::new();
for member in object.get_members() {
if member.get_member_type() != "OBJECT" {
write_string = format!(
"{}{}{}{}{}{}",
write_string,
"\t",
member.get_member_name(),
":",
member.get_member_type(),
",\n"
);
if member.get_member_type() == "TIME" {
write_string = format!(
"{}{}{}{}",
write_string,
"\t",
member.get_member_name().to_lowercase(),
":chrono::NativeDateTime,\n",
);
} else if !member.get_enumerations().is_empty() && member.get_enumerations().first().unwrap().get_name() != "" {
write_string = format!(
"{}{}{}{}{}{}",
write_string,
"\t",
member.get_member_name().to_lowercase(),
":",
member.get_member_name(),
",\n"
);
} else {
write_string = format!(
"{}{}{}{}{}{}",
write_string,
"\t",
member.get_member_name().to_lowercase(),
":",
member.get_member_type(),
",\n"
);
}
} else {
write_string = format!(
"{}{}{}{}{}{}{}{}",
write_string,
"\t",
member.get_member_name(),
member.get_member_name().to_lowercase(),
":",
member.get_member_type(),
"::",
@ -271,6 +291,11 @@ fn output_gen(family: oop::Family, output_path: String) -> (String, String){
enums.push(member)
}
}
write_string = format!(
"{}{}",
write_string,
"\t#[getter(skip)]\n\traw_object:RawObject,\n"
);
if !enums.is_empty() {
for member in enums {
@ -290,17 +315,14 @@ fn output_gen(family: oop::Family, output_path: String) -> (String, String){
",\n"
);
}
write_string = format!(
"{}{}",
write_string,
"\t#[getter(skip)]\n\traw_object:RawObject,\n"
);
}
}
write_string = format!(
"{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
write_string,
"}\n\nimpl Object for ",
"}\n\npub impl ",
object.get_name(),
" {\n\tfn new() -> Self { todo!() }\n}\nimpl Object for ",
object.get_name(),
"{\n\tfn get_family(&self) -> datatypes::Family { datatypes::Family::",
family.get_name(),
@ -308,7 +330,7 @@ fn output_gen(family: oop::Family, output_path: String) -> (String, String){
genus_name,
" }\n\tfn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(",
family.get_name().as_str(),
"Species:",
"Species::",
object.get_name(),
") }\n\tfn get_raw_object(&self) -> RawObject { self.raw_object.clone() }\n}\n\n"
);