FrogWithACoolHat/RustXMLParseTest
2
1
Fork 1
Code Issues 6 Pull requests 1 Projects Releases Packages Wiki Activity

Fixed multiple issues with object write string

Browse source
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
Download patch file Download diff file Expand all files Collapse all files

98
FmCO2_objects.rs
View file

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

329
FmECG_objects.rs
View file

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

392
FmNIBP_objects.rs
View file

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

146
FmSPO2_objects.rs
View file

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

390
FmTEMP_objects.rs
View file

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

60
src/main.rs
View file

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