FmCO2_members.rs

@@ -0,0 +1,31 @@
+use super::MessageSpecies;
+
+pub enum FmCO2Message{
+	GET_BREATH,			//Request 0
+	GET_AMBIENT_PRESSURE,			//Request 1
+	GET_MODULE_CONFIG,			//Request 2
+	GET_CALIBRATION,			//Request 3
+	GET_SERVICE_TIME,			//Request 4
+	GET_CAL_TIME,			//Request 5
+	GET_CONFIG,			//Request 6
+	PUT_BREATH,			//Response 0
+	PUT_AMBIENT_PRESSURE,			//Response 1
+	PUT_MODULE_CONFIG,			//Response 2
+	PUT_CALIBRATION,			//Response 3
+	PUT_SERVICE_TIME,			//Response 4
+	PUT_CAL_TIME,			//Response 5
+	PUT_CONFIG,			//Response 6
+	RESTART_BREATH_ALG,			//Command 0
+	START_CALIBRATION,			//Command 1
+	STOP_CALIBRATION,			//Command 2
+	FORCE_SFM,			//Command 3
+	PUMP_CONTROL,			//Command 4
+	START_SFM,			//Command 5
+	SET_MODULE_CONFIG,			//Command 6
+	START_ACQUIRE,			//Command 7
+	STOP_ACQUIRE,			//Command 8
+	WRITE_CONFIG,			//Command 9
+	STREAM_CO2,			//Stream 0
+}
+
+impl MessageSpecies for FmCO2Message{}

FmCO2_objects.rs

@@ -0,0 +1,195 @@
+use crate::datatypes;
+use super::{Object, ObjectSpecies, RawObject};
+use derive_getters::Getters;
+use derive_builder::Builder;
+use downcast_rs::Downcast
+
+pub trait FmCO2:Downcast{}
+
+#[derive(Clone,Debug)]
+pub enum FmCO2Species{
+	SpDATA,
+	SpCALIBRATION,
+	SpSTANDARD,
+	SpMSG_ARGUMENTS,
+}
+impl ObjectSpecies for FmCO2Species{}
+
+impl FmCO2 for CCO2DData{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CCO2DData{
+	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::NaiveDateTime,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Status{
+	#[default]
+	DATA_NOT_AVAIL,
+	DATA_COMPLETE,
+	DATA_FAILURE,
+	DATA_EXCEPTION,
+	DATA_PROCESSING,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum ExtStatus{
+	#[default]
+	INITIALIZATION,
+	SFM_REQUIRED,
+	SFM_IN_PROGRESS,
+	PURGING_IN_PROGRESS,
+	FILTER_LINE_NO_CONNECT,
+	CHECK_CALIBRATION,
+	CHECK_FLOW,
+	OCCLUSION_IN_GAS_LINE,
+	TEMPERATURE_OUT_OF_RANGE,
+	PUMP_OFF,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Source{
+	#[default]
+	NONE,
+	UNKNOWN,
+	BREATH_DETECTED,
+	INTERVAL,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Mode{
+	#[default]
+	NONE,
+	UNKNOWN,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Method{
+	#[default]
+	NONE,
+	UNKNOWN,
+	MANUAL,
+	DEVICE,
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmCO2 for CCO2CCal{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CCO2CCal{
+	status:Status,
+	method:Method,
+	gasconcentration:uint8,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Status{
+	#[default]
+	IN_PROGRESS,
+	NOT_READY,
+	CALCULATING,
+	COMPLETE_ERROR,
+	COMPLETE_SUCCESS,
+	USER_ABORT,
+	MEASUREMENT_ERROR,
+	AZ_FAIL,
+	GAS_CONCENTRATION_CHECK,
+	GAS_FLOW_UNSTABLE,
+	CALIBRATION_FAILURE,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Method{
+	#[default]
+	NONE,
+	REGULAR_CALIBRATION,
+	SPECIAL_FACTORY_CALIBRATION,
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmCO2 for CCO2CStd{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CCO2CStd{
+	displayunits:DisplayUnits,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum DisplayUnits{
+	#[default]
+	UNITS_MMHG,
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmCO2 for CCO2PMsgArg{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CCO2PMsgArg{
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+

FmECG_members.rs

@@ -0,0 +1,20 @@
+use super::MessageSpecies;
+
+pub enum FmECGMessage{
+	GET_CONFIG,			//Request 0
+	GET_LEADMEASUREMENT,			//Request 1
+	GET_MEASURMENTS,			//Request 2
+	GET_LEADIMPEDANCE,			//Request 3
+	GET_QRSCOMPLEX,			//Request 4
+	PUT_CONFIG,			//Response 0
+	PUT_LEADMEASUREMENT,			//Response 1
+	PUT_MEASUREMENTS,			//Response 2
+	PUT_LEADIMPEDANCE,			//Response 3
+	PUT_QRSCOMPLEX,			//Response 4
+	WRITE_CONFIG,			//Command 0
+	START_TEST,			//Command 1
+	STOP_TEST,			//Command 2
+	ECG_MODE,			//Command 3
+}
+
+impl MessageSpecies for FmECGMessage{}

FmECG_objects.rs

@@ -0,0 +1,644 @@
+use crate::datatypes;
+use super::{Object, ObjectSpecies, RawObject};
+use derive_getters::Getters;
+use derive_builder::Builder;
+use downcast_rs::Downcast
+
+pub trait FmECG:Downcast{}
+
+#[derive(Clone,Debug)]
+pub enum FmECGSpecies{
+	SpPACER,
+	SpGLOBALMEASURE,
+	SpLEADMEASURE,
+	SpSTATUS,
+	SpRHYTHMREPORT,
+	SpAUTOREPORT,
+	SpMISCELLANEOUS,
+	SpSTANDARD,
+	SpSETTINGS,
+	SpSELECTOR,
+}
+impl ObjectSpecies for FmECGSpecies{}
+
+impl FmECG for CECGDPacer{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CECGDPacer{
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmECG for CECGDGlobalMeas{}
+#[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,
+	#[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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmECG for CECGDLeadMeas{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CECGDLeadMeas{
+	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)]
+pub enum LeadIdentifier{
+	#[default]
+	I,
+	II,
+	III,
+	AVR,
+	AVL,
+	AVF,
+	V1,
+	V2,
+	V3,
+	V4,
+	V5,
+	V6,
+	V7,
+	V3R,
+	V5R,
+	X,
+	Y,
+	Z,
+	V4R,
+	V6R,
+	V8,
+	V9,
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmECG for CECGDStatus{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CECGDStatus{
+	electrodeoffstatus:ElectrodeOffStatus,
+	arrhythmiastatus:byte,
+	activeleads:ActiveLeads,
+	container:OBJECT::ANY_CLASS,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum ElectrodeOffStatus{
+	#[default]
+	ELECTRODE_RL,
+	ELECTRODE_LL,
+	ELECTRODE_RA,
+	ELECTRODE_LA,
+	ELECTRODE_V,
+	ELECTRODE_V1,
+	ELECTRODE_V2,
+	ELECTRODE_V3,
+	ELECTRODE_V4,
+	ELECTRODE_V5,
+	ELECTRODE_V6,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum ActiveLeads{
+	#[default]
+	ECG_I,
+	ECG_II,
+	ECG_III,
+	ECG_aVR,
+	ECG_aVL,
+	ECG_aVF,
+	ECG_V,
+	ECG_V1,
+	ECG_V2,
+	ECG_V3,
+	ECG_V4,
+	ECG_V5,
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmECG for CECGCRhythmReport{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CECGCRhythmReport{
+	leadarrangement:LeadArrangement,
+	defspeedsetting:DefSpeedSetting,
+	stdleadorder:uint8,
+	augleadorder:uint8,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum LeadArrangement{
+	#[default]
+	3LEAD,
+	6LEAD,
+	12LEAD,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum DefSpeedSetting{
+	#[default]
+	10mm_s,
+	25mm_s,
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmECG for CECGCAutoReport{}
+#[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: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)]
+pub enum AgeFormat{
+	#[default]
+	DOB,
+	AGE,
+	OFF,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum LeadArrangement{
+	#[default]
+	3X4,
+	3X4_1R,
+	3X4_3R,
+	6X2,
+	12X1,
+	6X2_50mm,
+	6X2_ext,
+	2X6_1R,
+	NOPRINT,
+	6X2_1R,
+	2X6,
+	3x4_25mm_5sec,
+	3x4_50mm,
+	3x4_50mm_5sec,
+	6x2_25mm,
+	6x2_50mm_5sec,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum RhythLd1{
+	#[default]
+	I,
+	II,
+	III,
+	AVR,
+	AVL,
+	AVF,
+	V1,
+	V2,
+	V3,
+	V4,
+	V5,
+	V6,
+	OFF,
+	V7,
+	V3R,
+	V5R,
+	X,
+	Y,
+	Z,
+	V4R,
+	V6R,
+	V8,
+	V9,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum RhythLd2{
+	#[default]
+	I,
+	II,
+	III,
+	AVR,
+	AVL,
+	AVF,
+	V1,
+	V2,
+	V3,
+	V4,
+	V5,
+	V6,
+	OFF,
+	V7,
+	V3R,
+	V5R,
+	X,
+	Y,
+	Z,
+	V4R,
+	V6R,
+	V8,
+	V9,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum RhythLd3{
+	#[default]
+	I,
+	II,
+	III,
+	AVR,
+	AVL,
+	AVF,
+	V1,
+	V2,
+	V3,
+	V4,
+	V5,
+	V6,
+	OFF,
+	V7,
+	V3R,
+	V5R,
+	X,
+	Y,
+	Z,
+	V4R,
+	V6R,
+	V8,
+	V9,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum AvgCycle{
+	#[default]
+	3x4_3R,
+	6x2_6R,
+	NOPRINT,
+	3x4_2R_25mm,
+	3x4_2R,
+	3x4_3R_25mm,
+	2x6_1R_25mm,
+	2x6_1R,
+	6x2_2R,
+	6x2_1R_25mm,
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmECG for CECGCMiscellaneous{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CECGCMiscellaneous{
+	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)]
+pub enum LeadConfig{
+	#[default]
+	STANDARD,
+	CABRERA,
+	NEHB,
+	FRANK,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Mains{
+	#[default]
+	OFF,
+	50HZ,
+	60HZ,
+	AUTO,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum AutoExport{
+	#[default]
+	OFF,
+	MEDIACARD,
+	FAA,
+	FAX,
+	WORKSTATION,
+	REMOTE,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum ElectrodeLbl{
+	#[default]
+	AHA,
+	IEC,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum LeadTiming{
+	#[default]
+	SIMOULTANEOUS,
+	SEQUENTIAL,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum DefGainSetting{
+	#[default]
+	5mm_mv,
+	10mm_mv,
+	20mm_mv,
+	AUTO,
+	2mm5_mv,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum ElectrodePlacement{
+	#[default]
+	STANDARD,
+	ALTERNATE,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum QTcMethod{
+	#[default]
+	BAZETT,
+	HODGES,
+	FRIDERICIA,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum QRSTone{
+	#[default]
+	NONE,
+	FREQ_1KHZ,
+	FREQ_2KHZ,
+	FREQ_2K67HZ,
+	FREQ_3K2HZ,
+	FREQ_4KHZ,
+	FREQ_5K3HZ,
+	FREQ_6K4HZ,
+	FREQ_8KHZ,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum PrintLabel{
+	#[default]
+	NONE,
+	PR,
+	PQ,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum PacerLead{
+	#[default]
+	NONE,
+	I,
+	II,
+	V1,
+	V2,
+	V3,
+	V4,
+	V5,
+	V6,
+	V7,
+	V8,
+	V9,
+	V3R,
+	V4R,
+	V5R,
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmECG for CECGCSettings{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CECGCSettings{
+	activeleads:ActiveLeads,
+	mainsfilter:MainsFilter,
+	pacerenabled:boolean,
+	leadmode:LeadMode,
+	vtachthreshold:uint8,
+	impedancerespiration:boolean,
+	asystolethreshold:uint16,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum ActiveLeads{
+	#[default]
+	ECG_I,
+	ECG_II,
+	ECG_III,
+	ECG_aVR,
+	ECG_aVL,
+	ECG_aVF,
+	ECG_V,
+	ECG_V1,
+	ECG_V2,
+	ECG_V3,
+	ECG_V4,
+	ECG_V5,
+	ECG_V6,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum MainsFilter{
+	#[default]
+	NONE,
+	OFF,
+	50HZ,
+	60HZ,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum LeadMode{
+	#[default]
+	NONE,
+	UNKNOWN,
+	3_LEAD,
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmECG for CECGPSelector{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CECGPSelector{
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+

FmNIBP_members.rs

@@ -0,0 +1,52 @@
+use super::MessageSpecies;
+
+pub enum FmNIBPMessage{
+	GET_BP,			//Request 0
+	GET_CONFIG,			//Request 1
+	GET_STATUS,			//Request 2
+	GET_CALIBRATION,			//Request 3
+	GET_BP_SETTINGS,			//Request 4
+	GET_CHUNK,			//Request 5
+	GET_CHUNK_SIZE,			//Request 6
+	GET_MAX_CHUNK_ID,			//Request 7
+	GET_HARDWARE_STATE,			//Request 8
+	GET_TEST_LOCK,			//Request 9
+	GET_RAW_DATA,			//Request 10
+	GET_PRESSURE_DATA,			//Request 11
+	PUT_BP,			//Response 0
+	PUT_CONFIG,			//Response 1
+	PUT_STATUS,			//Response 2
+	PUT_CALIBRATION,			//Response 3
+	PUT_BP_SETTINGS,			//Response 4
+	PUT_CHUNK,			//Response 5
+	PUT_CHUNK_SIZE,			//Response 6
+	PUT_MAX_CHUNK_ID,			//Response 7
+	PUT_HARDWARE_STATE,			//Response 8
+	PUT_TEST_LOCK,			//Response 9
+	PUT_RAW_DATA,			//Response 10
+	PUT_PRESSURE_DATA,			//Response 11
+	START_NIBP,			//Command 0
+	STOP_NIBP,			//Command 1
+	WRITE_CONFIG,			//Command 2
+	ZERO_NIBP,			//Command 3
+	MSG_PUSH_ENABLE,			//Command 4
+	CLEAR_SAFTEY_STATUS,			//Command 5
+	CLEAR_POST_STATUS,			//Command 6
+	RESET_DEVICE,			//Command 7
+	SET_CALIBRATION,			//Command 8
+	SAVE_CALIBRATION,			//Command 9
+	LOAD_CALIBRATION,			//Command 10
+	RESTORE_DFLT_CALIBRATION,			//Command 11
+	SET_BP_SETTINGS,			//Command 12
+	SAVE_BP_SETTINGS,			//Command 13
+	LOAD_BP_SETTINGS,			//Command 14
+	RESTORE_DFLT_SETTINGS,			//Command 15
+	SET_HARDWARE_STATE,			//Command 16
+	PULSE_STEP_VALVE,			//Command 17
+	SET_TEST_LOCK,			//Command 18
+	REPORT_BP,			//Status 0
+	REPORT_BP,			//Stream 0
+	REPORT_STATUS,			//Stream 1
+}
+
+impl MessageSpecies for FmNIBPMessage{}

FmNIBP_objects.rs

@@ -0,0 +1,657 @@
+use crate::datatypes;
+use super::{Object, ObjectSpecies, RawObject};
+use derive_getters::Getters;
+use derive_builder::Builder;
+use downcast_rs::Downcast
+
+pub trait FmNIBP:Downcast{}
+
+#[derive(Clone,Debug)]
+pub enum FmNIBPSpecies{
+	SpSTANDARD,
+	SpDATA,
+	SpENGCHUNK,
+	SpEVENTCHUNK,
+	SpHARDWARESTATE,
+	SpLOCK,
+	SpRAWDATA,
+	SpPRESSUREDATA,
+	SpSTATUS,
+	SpDATAMODIFIED,
+	SpCALIBRATION,
+	SpSELECTOR,
+	SpCHUNK_SELECTOR,
+}
+impl ObjectSpecies for FmNIBPSpecies{}
+
+impl FmNIBP for CNIBPDStd{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CNIBPDStd{
+	stime:chrono::NaiveDateTime,
+	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)]
+pub enum Status{
+	#[default]
+	DATA_NOT_AVAIL,
+	DATA_COMPLETE,
+	DATA_FAILURE,
+	DATA_EXCEPTION,
+	DATA_PROCESSING,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum ExtStatus{
+	#[default]
+	NONE,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Source{
+	#[default]
+	NONE,
+	UNKNOWN,
+	CVSM,
+	MODB,
+	MODF,
+	POEM,
+	MODG,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Mode{
+	#[default]
+	NONE,
+	UNKNOWN,
+	ADULT,
+	NEONATAL,
+	PEDIATRIC,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Method{
+	#[default]
+	NONE,
+	UNKNOWN,
+	MANUAL,
+	DEVICE,
+	REMOTE,
+	FAST_BP,
+	STEP_BP,
+	NEONATAL_STEP_BP,
+	LINEAR_DEFLATION_BP,
+	AVERAGE_BP,
+}
+
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmNIBP for CNIBPDData{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CNIBPDData{
+	status:Status,
+	systolic:OBJECT::CNumDStd,
+	diastolic:OBJECT::CNumDStd,
+	map:OBJECT::CNumDStd,
+	pr:OBJECT::CNumDStd,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Status{
+	#[default]
+	RD_OK,
+	RD_ABORT,
+	RD_NOT_AVAIL,
+	RD_SPLAT,
+	RD_ARTIFACT,
+	RD_LOW_INFLAT,
+	RD_KINKED_TUBE,
+	RD_EARLY_DUMP,
+	RD_NOT_ENOUGH_DATA,
+	RD_PATIENT_INVALID,
+	RD_REINF_TOO_LATE,
+	RD_REINF_LIMIT,
+	RD_BLEED,
+	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() }
+}
+
+impl FmNIBP for CNIBPDChunk{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CNIBPDChunk{
+	tag:int8,
+	chunkid:uint16,
+	chunkindex:uint16,
+	chunkdata:uint8,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+pub impl CNIBPDChunk {
+	fn new() -> Self { todo!() }
+}
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmNIBP for CNIBPDHState{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CNIBPDHState{
+	hardware:hardware,
+	state:int16,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum hardware{
+	#[default]
+	PRIM_VALVE,
+	SEC_VALVE,
+	PUMP,
+}
+
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmNIBP for CNIBPDLock{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CNIBPDLock{
+	lock:lock,
+	state:int8,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum lock{
+	#[default]
+	AMB_TEMP_CHECK,
+	PRIM_SAFETY_CHECK,
+	SAFE_SAFETY_CHECK,
+	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() }
+}
+
+impl FmNIBP for CNIBPDRData{}
+#[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,
+}
+
+pub impl CNIBPDRData {
+	fn new() -> Self { todo!() }
+}
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmNIBP for CNIBPDPData{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CNIBPDPData{
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmNIBP for CNIBPDStatus{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CNIBPDStatus{
+	modulestate:moduleState,
+	error:uint16,
+	hardwarestates:uint16,
+	safetystates:safetyStates,
+	cuffpressure:int16,
+	batvoltage:int16,
+	ambtemp:int16,
+	statustype:statusType,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum moduleState{
+	#[default]
+	IDLE,
+	AUTOZERO,
+	INFLATING,
+	STABILIZING,
+	BLEEDING,
+	DUMPING,
+	REPUMP,
+	ERROR,
+	BOOT,
+	POST,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum safetyStates{
+	#[default]
+	belowResidual,
+	longAutoTimerClear,
+	statAutoTimerClear,
+	failsafeFault,
+	autoZeroFault,
+	transducerFault,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum statusType{
+	#[default]
+	NONE,
+	PRIMARY,
+	SECONDARY,
+}
+
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmNIBP for CNIBPDDataModified{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CNIBPDDataModified{
+	nibpdata:OBJECT::CNIBPDData,
+	status:Status,
+	stime:chrono::NaiveDateTime,
+	mode:Mode,
+	patientposition:PatientPosition,
+	cuffsize:CuffSize,
+	cufflocation:CuffLocation,
+	source:Source,
+	method:Method,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Status{
+	#[default]
+	DATA_NOT_AVAIL,
+	DATA_COMPLETE,
+	DATA_FAILURE,
+	DATA_EXCEPTION,
+	DATA_PROCESSING,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Mode{
+	#[default]
+	NONE,
+	UNKNOWN,
+	ADULT,
+	NEONATAL,
+	PEDIATRIC,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum PatientPosition{
+	#[default]
+	NONE,
+	UNKNOWN,
+	LYING,
+	SITTING,
+	STANDING,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum CuffSize{
+	#[default]
+	NONE,
+	UNKNOWN,
+	NEONATAL_1,
+	NEONATAL_2,
+	NEONATAL_3,
+	NEONATAL_4,
+	NEONATAL_5,
+	SMALL_INFANT,
+	INFANT,
+	SMALL_CHILD,
+	CHILD,
+	SMALL_ADULT,
+	ADULT,
+	ADULT_LONG,
+	LARGE_ADULT,
+	LARGE_ADULT_LONG,
+	THIGH,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum CuffLocation{
+	#[default]
+	NONE,
+	UNKNOWN,
+	LEFT_ARM,
+	RIGHT_ARM,
+	LEFT_LEG,
+	RIGHT_LEG,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Source{
+	#[default]
+	NONE,
+	UNKNOWN,
+	CVSM,
+	MODB,
+	MODF,
+	POEM,
+	MODG,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Method{
+	#[default]
+	NONE,
+	UNKNOWN,
+	MANUAL,
+	DEVICE,
+	REMOTE,
+	FAST_BP,
+	STEP_BP,
+	NEONATAL_STEP_BP,
+	LINEAR_DEFLATION_BP,
+	AVERAGE_BP,
+}
+
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmNIBP for CNIBPCStd{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CNIBPCStd{
+	displayunits:DisplayUnits,
+	mapdisplay:MAPDisplay,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum DisplayUnits{
+	#[default]
+	NIBP_MMHG,
+	NIBP_KPA,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum MAPDisplay{
+	#[default]
+	DISABLE,
+	ENABLE,
+}
+
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmNIBP for CNIBPCData{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CNIBPCData{
+	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)]
+pub enum dfltPatientMode{
+	#[default]
+	ADULT,
+	PEDIATRIC,
+	NEONATE,
+}
+
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmNIBP for CNIBPCCal{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CNIBPCCal{
+	caltype:calType,
+	calsignature:int32,
+	caldatetime:chrono::NaiveDateTime,
+	modconfig:int16,
+	spancorr:int16,
+	zerocorr:int16,
+	battcal:int16,
+	tempcal:int16,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum calType{
+	#[default]
+	NONE,
+	PRIMARY,
+	SECONDARY,
+}
+
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmNIBP for CNIBPPData{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CNIBPPData{
+	targpress:int16,
+	patientmode:patientMode,
+	cyclemode:cycleMode,
+	algorithm:algorithm,
+	disableneocheck:int8,
+	firstreading:boolean,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum patientMode{
+	#[default]
+	DEFAULT,
+	ADULT,
+	PEDIATRIC,
+	NEONATE,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum cycleMode{
+	#[default]
+	MANUAL,
+	LONG_AUTO,
+	STAT,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum algorithm{
+	#[default]
+	DEFAULT,
+	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() }
+}
+
+impl FmNIBP for CNIBPPSelector{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CNIBPPSelector{
+	value:uint32,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+pub impl CNIBPPSelector {
+	fn new() -> Self { todo!() }
+}
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmNIBP for CNIBPPChunkSelector{}
+#[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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmNIBP for CNIBPDExtStd{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CNIBPDExtStd{
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+

FmSPO2_members.rs

@@ -0,0 +1,15 @@
+use super::MessageSpecies;
+
+pub enum FmSPO2Message{
+	GET_SPO2,			//Request 0
+	GET_CONFIG,			//Request 1
+	PUT_SPO2,			//Response 0
+	PUT_CONFIG,			//Response 1
+	WRITE_CONFIG,			//Command 0
+	START_ACQUIRE,			//Command 1
+	STOP_ACQUIRE,			//Command 2
+	REPORT_SPO2,			//Status 0
+	STREAM_SPO2,			//Stream 0
+}
+
+impl MessageSpecies for FmSPO2Message{}

FmSPO2_objects.rs

@@ -0,0 +1,375 @@
+use crate::datatypes;
+use super::{Object, ObjectSpecies, RawObject};
+use derive_getters::Getters;
+use derive_builder::Builder;
+use downcast_rs::Downcast
+
+pub trait FmSPO2:Downcast{}
+
+#[derive(Clone,Debug)]
+pub enum FmSPO2Species{
+	SpSTANDARD,
+	SpDATA,
+	SpDATAMODIFIED,
+	SpSELECTOR,
+}
+impl ObjectSpecies for FmSPO2Species{}
+
+impl FmSPO2 for CSpO2DStd{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CSpO2DStd{
+	stime:chrono::NaiveDateTime,
+	status:Status,
+	sat:uint16,
+	hr:uint16,
+	extstatus:ExtStatus,
+	source:Source,
+	mode:Mode,
+	method:Method,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Status{
+	#[default]
+	DATA_NOT_AVAIL,
+	DATA_COMPLETE,
+	DATA_FAILURE,
+	DATA_EXCEPTION,
+	DATA_PROCESSING,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum ExtStatus{
+	#[default]
+	NONE,
+	SPO2_NOPROBE,
+	SPO2_NOTAVAIL,
+	SPO2_OUT_OF_TRACK,
+	SPO2_BAD,
+	SPO2_WAIT,
+	SPO2_SENSOR_BAD,
+	SPO2_FROZEN,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Source{
+	#[default]
+	NONE,
+	UNKNOWN,
+	NONIN,
+	NELLCOR_MP205,
+	NELLCOR_MP506,
+	MASIMO_MS11,
+	NELLCOR_NELL3,
+	NELLCOR_NELL1,
+	MASIMO_MS2011,
+	MASIMO_MX,
+	NELLCOR,
+	NELLCOR_PMB05N,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Mode{
+	#[default]
+	NONE,
+	UNKNOWN,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Method{
+	#[default]
+	NONE,
+	UNKNOWN,
+	MANUAL,
+	DEVICE,
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmSPO2 for CSpO2DData{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CSpO2DData{
+	stime:chrono::NaiveDateTime,
+	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)]
+pub enum ExtStatus{
+	#[default]
+	PULSE_FOUND,
+	SEARCHING_FOR_BOARD,
+	NO_PROBE,
+	INCORRECT_PROBE,
+	SEARCHING_FOR_PULSE,
+	BAD_PROBE,
+	PROBE_EXPIRED,
+	NO_CABLE,
+	INCORRECT_CABLE,
+	BAD_CABLE,
+	CABLE_EXPIRED,
+	VALUE_NOT_ACQUIRED,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Source{
+	#[default]
+	NONE,
+	UNKNOWN,
+	NONIN,
+	NELLCOR_MP205,
+	NELLCOR_MP506,
+	MASIMO_MS11,
+	NELLCOR_NELL3,
+	NELLCOR_NELL1,
+	MASIMO_MS2011,
+	MASIMO_MX,
+	NELLCOR,
+	NELLCOR_PMB05N,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Status{
+	#[default]
+	DATA_NOT_AVAIL,
+	DATA_COMPLETE,
+	DATA_FAILURE,
+	DATA_EXCEPTION,
+	DATA_PROCESSING,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Mode{
+	#[default]
+	NONE,
+	UNKNOWN,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Method{
+	#[default]
+	NONE,
+	UNKNOWN,
+	MANUAL,
+	DEVICE,
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmSPO2 for CSpO2DDataModified{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CSpO2DDataModified{
+	spo2data:OBJECT::CSpO2DData,
+	o2flowrate:uint8,
+	o2concentration:uint8,
+	o2method:O2Method,
+	location:Location,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum O2Method{
+	#[default]
+	NONE,
+	UNKNOWN,
+	AEROSOL_HUMIDIFIED_MASK,
+	FACE_TENT,
+	MASK,
+	NASAL_CANNULA,
+	NON_REBREATHER,
+	PARTIAL_REBREATHER,
+	T_PIECE,
+	TRACHEOSTOMY_COLLAR,
+	VENTILATOR,
+	VENTURI_MASK,
+	ROOM_AIR,
+	OXYMIZER,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Location{
+	#[default]
+	NONE,
+	UNKNOWN,
+	EAR,
+	FINGER,
+	TOE,
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmSPO2 for CSpO2CStd{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CSpO2CStd{
+	enabled:boolean,
+	installedmodule:InstalledModule,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum InstalledModule{
+	#[default]
+	NONE,
+	UNKNOWN,
+	NONIN,
+	NELLCOR_MP205,
+	NELLCOR_MP506,
+	MASIMO_MS11,
+	NELLCOR_NELL3,
+	NELLCOR_NELL1,
+	MASIMO_MS2011,
+	MASIMO_MX,
+	NELLCOR,
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmSPO2 for CSpO2CData{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CSpO2CData{
+	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)]
+pub enum FastSat{
+	#[default]
+	NONE,
+	OFF,
+	ON,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Sensitivity{
+	#[default]
+	NONE,
+	NORMAL,
+	MAXIMUM,
+	APOD,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum AveragingTime{
+	#[default]
+	NONE,
+	2_TO_4_SEC,
+	4_TO_6_SEC,
+	8_SEC,
+	10_SEC,
+	12_SEC,
+	14_SEC,
+	16_SEC,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum SatSecondsLimit{
+	#[default]
+	NONE,
+	DISABLED,
+	10_SEC,
+	25_SEC,
+	50_SEC,
+	100_SEC,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum SmartTone{
+	#[default]
+	NONE,
+	OFF,
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmSPO2 for CSpO2PSelector{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CSpO2PSelector{
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+

FmTEMP_members.rs

@@ -0,0 +1,59 @@
+use super::MessageSpecies;
+
+pub enum FmTEMPMessage{
+	GET_TEMP,			//Request 0
+	GET_CONFIG,			//Request 1
+	GET_ENG_STATUS,			//Request 2
+	STATUS,			//Request 3
+	GET_PROBE_INFO,			//Request 4
+	GET_CALIBRATION,			//Request 5
+	GET_SETTINGS,			//Request 6
+	GET_HARDWARE_STATE,			//Request 7
+	GET_TEST_LOCK,			//Request 8
+	GET_RAW_DATA,			//Request 9
+	GET_SAMPLE,			//Request 10
+	GET_TOUCH,			//Request 11
+	GET_THERM,			//Request 12
+	GET_THERMOMETER_SETTINGS,			//Request 13
+	PUT_TEMP,			//Response 0
+	PUT_CONFIG,			//Response 1
+	PUT_ENG_STATUS,			//Response 2
+	PUT_STATUS,			//Response 3
+	PUT_PROBE_INFO,			//Response 4
+	PUT_CALIBRATION,			//Response 5
+	PUT_SETTINGS,			//Response 6
+	PUT_HARDWARE_STATE,			//Response 7
+	PUT_TEST_LOCK,			//Response 8
+	PUT_RAW_DATA,			//Response 9
+	PUT_SAMPLE,			//Response 10
+	PUT_TOUCH,			//Response 11
+	PUT_THERM,			//Response 12
+	PUT_THERMOMETER_SETTINGS,			//Response 13
+	WRITE_CONFIG,			//Command 0
+	MSG_PUSH_ENABLE,			//Command 1
+	MSG_SET_ALG,			//Command 2
+	MSG_SET_MODE,			//Command 3
+	RESET_DEVICE,			//Command 4
+	SET_CALIBRATION,			//Command 5
+	SAVE_CALIBRATION,			//Command 6
+	LOAD_CALIBRATION,			//Command 7
+	RESTORE_DFLT_CALIBRATION,			//Command 8
+	SET_SETTINGS,			//Command 9
+	SAVE_SETTINGS,			//Command 10
+	LOAD_SETTINGS,			//Command 11
+	RESTORE_DFLT_SETTINGS,			//Command 12
+	SET_HARDWARE_STATE,			//Command 13
+	SET_TEST_LOCK,			//Command 14
+	SET_THERM,			//Command 15
+	START_ACQUIRE,			//Command 16
+	STOP_ACQUIRE,			//Command 17
+	WRITE_THERMOMETER_SETTINGS,			//Command 18
+	REPORT_TEMPERATURE,			//Status 0
+	REPORT_ENG_STATUS,			//Stream 0
+	REPORT_STATUS,			//Stream 1
+	REPORT_SAMPLE,			//Stream 2
+	REPORT_TOUCH,			//Stream 3
+	REPORT_THERM,			//Stream 4
+}
+
+impl MessageSpecies for FmTEMPMessage{}

FmTEMP_objects.rs

@@ -0,0 +1,850 @@
+use crate::datatypes;
+use super::{Object, ObjectSpecies, RawObject};
+use derive_getters::Getters;
+use derive_builder::Builder;
+use downcast_rs::Downcast
+
+pub trait FmTEMP:Downcast{}
+
+#[derive(Clone,Debug)]
+pub enum FmTEMPSpecies{
+	SpSTANDARD,
+	SpDATA,
+	SpENGDATA,
+	SpPROBEDATA,
+	SpHARDWARESTATE,
+	SpLOCK,
+	SpRAWDATA,
+	SpSTATUS,
+	SpADSAMPLEDATA,
+	SpTOUCHDATA,
+	SpTHERMDATA,
+	SpCALIBRATION,
+	SpMSG_ARGUMENTS,
+	SpSELECTOR,
+}
+impl ObjectSpecies for FmTEMPSpecies{}
+
+impl FmTEMP for CTempDStd{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CTempDStd{
+	stime:chrono::NaiveDateTime,
+	status:Status,
+	extstatus:ExtStatus,
+	source:Source,
+	mode:Mode,
+	method:Method,
+	temperature:float,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Status{
+	#[default]
+	DATA_NOT_AVAIL,
+	DATA_COMPLETE,
+	DATA_FAILURE,
+	DATA_EXCEPTION,
+	DATA_PROCESSING,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum ExtStatus{
+	#[default]
+	NONE,
+	FINAL_POSITION,
+	FINAL_OVER_TEMP,
+	FINAL_OVER_TEMP_POSITION,
+	FINAL_UNDER_TEMP,
+	FINAL_UNDER_TEMP_POSITION,
+	MONITOR_POSITION,
+	MONITOR_OVER_TEMP,
+	MONITOR_OVER_TEMP_POSITION,
+	MONITOR_UNDER_TEMP,
+	MONITOR_UNDER_TEMP_POSITION,
+	CRC_FAILURE,
+	COMM_FAILURE,
+	FINAL_UNADJUSTED,
+	BUTTON_RANGE_ERROR,
+	AMB_RANGE_ERROR,
+	ENTRY_RANGE_ERROR,
+	TT_RANGE_ERROR,
+	TT_SLOPE_RANGE_ERROR,
+	OUTPUT_RANGE_ERROR,
+	CAP_STABILITY_ERROR,
+	CAP_ENTRY_ERROR,
+	PREMATURE_BUTTON_PRESS,
+	CALIBRATION,
+	UNADJUSTED_NO_OFFSETS,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Source{
+	#[default]
+	NONE,
+	UNKNOWN,
+	SURETEMP_SW,
+	SURETEMP,
+	SURETEMP_PLUS,
+	BRAUN_PRO4000,
+	BRAUN_PRO6000,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Mode{
+	#[default]
+	NONE,
+	UNKNOWN,
+	ORAL,
+	RECTAL,
+	PED_AXIL,
+	CAL_KEY,
+	ADULT_AXIL,
+	TYMPANIC,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Method{
+	#[default]
+	NONE,
+	UNKNOWN,
+	MANUAL,
+	DEVICE,
+	REMOTE,
+	PREDICT,
+	MONITOR,
+	IR,
+	BRAUN_CALC,
+	TECHNIQUE_COMPENSATION_CALC,
+}
+
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmTEMP for CTempDData{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CTempDData{
+	stime:chrono::NaiveDateTime,
+	status:Status,
+	extstatus:ExtStatus,
+	source:Source,
+	mode:Mode,
+	method:Method,
+	temperature:OBJECT::CNumDFloat,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Status{
+	#[default]
+	DATA_NOT_AVAIL,
+	DATA_COMPLETE,
+	DATA_FAILURE,
+	DATA_EXCEPTION,
+	DATA_PROCESSING,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum ExtStatus{
+	#[default]
+	NONE,
+	FINAL_POSITION,
+	FINAL_OVER_TEMP,
+	FINAL_OVER_TEMP_POSITION,
+	FINAL_UNDER_TEMP,
+	FINAL_UNDER_TEMP_POSITION,
+	MONITOR_POSITION,
+	MONITOR_OVER_TEMP,
+	MONITOR_OVER_TEMP_POSITION,
+	MONITOR_UNDER_TEMP,
+	MONITOR_UNDER_TEMP_POSITION,
+	CRC_FAILURE,
+	COMM_FAILURE,
+	FINAL_UNADJUSTED,
+	BUTTON_RANGE_ERROR,
+	AMB_RANGE_ERROR,
+	ENTRY_RANGE_ERROR,
+	TT_RANGE_ERROR,
+	TT_SLOPE_RANGE_ERROR,
+	OUTPUT_RANGE_ERROR,
+	CAP_STABILITY_ERROR,
+	CAP_ENTRY_ERROR,
+	PREMATURE_BUTTON_PRESS,
+	CALIBRATION,
+	UNADJUSTED_NO_OFFSETS,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Source{
+	#[default]
+	NONE,
+	UNKNOWN,
+	SURETEMP_SW,
+	SURETEMP,
+	SURETEMP_PLUS,
+	BRAUN_PRO4000,
+	BRAUN_PRO6000,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Mode{
+	#[default]
+	NONE,
+	UNKNOWN,
+	ORAL,
+	RECTAL,
+	PED_AXIL,
+	CAL_KEY,
+	ADULT_AXIL,
+	TYMPANIC,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Method{
+	#[default]
+	NONE,
+	UNKNOWN,
+	MANUAL,
+	DEVICE,
+	REMOTE,
+	PREDICT,
+	MONITOR,
+	IR,
+	BRAUN_CALC,
+	TECHNIQUE_COMPENSATION_CALC,
+}
+
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmTEMP for CSTPTempDEng{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CSTPTempDEng{
+	temp:float,
+	probe_temp:float,
+	heater:uint16,
+	reserved_1:uint16,
+	method:method,
+	algo:algo,
+	status:status,
+	error:error,
+	active:uint8,
+	probe_type:probe_type,
+	resistance:float,
+	ambient_temp:float,
+	ptb_resistance:float,
+	battery:uint16,
+	probe_temp_min:float,
+	probe_temp_max:float,
+	complete:uint8,
+	sample:uint32,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum method{
+	#[default]
+	PREDICT,
+	MONITOR,
+	CLINICAL,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum algo{
+	#[default]
+	NONE,
+	ORAL_ALG,
+	PED_AX_ALG,
+	ADULT_AX_ALG,
+	RECTAL_ALG,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum status{
+	#[default]
+	IDLE,
+	NOT_READY,
+	READY,
+	PREDICT,
+	PREDICT_DISPLAY,
+	PREDICT_POS,
+	FINAL,
+	FINAL_POS,
+	FINAL_OVER_TEMP,
+	FINAL_UNDER_TEMP,
+	FINAL_OVER_TEMP_POS,
+	FINAL_UNDER_TEMP_POS,
+	NO_PREDICT,
+	ERROR,
+	MONITOR,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum error{
+	#[default]
+	NO_ERROR,
+	ERROR_ALG_PROBE_OVER_TEMP,
+	ERROR_ALG_EXCESSIVE_HTR_ENERGY,
+	ERROR_ALG_OVER_AMB_TEMP,
+	ERROR_ALG_UNDER_AMB_TEMP,
+	ERROR_ALG_NO_PROBE_TEMP_RISE,
+	ERROR_ALG_BAD_PROBE_GAIN,
+	ERROR_ALG_BAD_PROBE_RESP_VAL,
+	ERROR_HTR_ON_NOT_OFF,
+	ERROR_HTR_OFF_NOT_ON,
+	ERROR_HTR_VOLT_HIGH_Q,
+	ERROR_HTR_VOLT_Q_HIGH_IMP,
+	ERROR_HTR_VOLT_LOW,
+	ERROR_HTR_FAILSAFE,
+	ERROR_AD_PULSE_LONG,
+	ERROR_AD_PULSE_SHORT,
+	ERROR_AD_RCAL_LONG,
+	ERROR_AD_RCAL_SHORT,
+	ERROR_AD_PTB_OVER,
+	ERROR_AD_PTB_UNDER,
+	ERROR_AD_TIMEOUT,
+	ERROR_CFG_XFER,
+	ERROR_CFG_SET_CRC,
+	ERROR_CFG_PROBE_CRC,
+	ERROR_CFG_CAL_CRC,
+	ERROR_CFG_LOG_CRC,
+	ERROR_CFG_NO_PROBE,
+	ERROR_CFG_UNIT_PROBE,
+	ERROR_CFG_ACK,
+	ERROR_CFG_INIT,
+	ERROR_BAT_HIGH,
+	ERROR_BAT_LOW,
+	ERROR_BAD_VIBES,
+	ERROR_NO_PROBE_WELL,
+	ERROR_POST_FAIL,
+	ERROR_INTERNAL_FAULT,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum probe_type{
+	#[default]
+	NO_PROBE,
+	ORAL,
+	RECTAL,
+	CALKEY,
+}
+
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmTEMP for CSTPDProbe{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CSTPDProbe{
+	probetype:probeType,
+	partnumber:int8,
+	lotcode:uint32,
+	lotseqnum:int16,
+	probearrayloc:int16,
+	testpassfailcode:int16,
+	calsignature:int32,
+	caldatetime:chrono::NaiveDateTime,
+	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,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum probeType{
+	#[default]
+	ORAL,
+	CALKEY,
+	RECTAL,
+	NONE,
+}
+
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmTEMP for CSTPDHState{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CSTPDHState{
+	hardware:hardware,
+	state:int16,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum hardware{
+	#[default]
+	PROBE_WELL_SW,
+	PROBE_SW,
+	PROBE_CONNECTED_SW,
+}
+
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmTEMP for CSTPDLock{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CSTPDLock{
+	lock:lock,
+	state:int8,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+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() }
+}
+
+impl FmTEMP for CSTPDRData{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CSTPDRData{
+	thermistor:uint32,
+	ptbresistor:uint32,
+	rcalresistor:uint32,
+	vref:uint32,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+pub impl CSTPDRData {
+	fn new() -> Self { todo!() }
+}
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmTEMP for CSTPDStat{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CSTPDStat{
+	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)]
+pub enum state{
+	#[default]
+	IDLE,
+	NOT_READY,
+	READY,
+	PREDICT,
+	PREDICT_DISPLAY,
+	PREDICT_POS,
+	FINAL,
+	FINAL_POS,
+	FINAL_OVER_TEMP,
+	FINAL_UNDER_TEMP,
+	FINAL_OVER_TEMP_POS,
+	FINAL_UNDER_TEMP_POS,
+	NO_PREDICT,
+	ERROR,
+	MONITOR,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum error{
+	#[default]
+	NO_ERROR,
+	ERROR_ALG_PROBE_OVER_TEMP,
+	ERROR_ALG_EXCESSIVE_HTR_ENERGY,
+	ERROR_ALG_OVER_AMB_TEMP,
+	ERROR_ALG_UNDER_AMB_TEMP,
+	ERROR_ALG_NO_PROBE_TEMP_RISE,
+	ERROR_ALG_BAD_PROBE_GAIN,
+	ERROR_ALG_BAD_PROBE_RESP_VAL,
+	ERROR_HTR_ON_NOT_OFF,
+	ERROR_HTR_OFF_NOT_ON,
+	ERROR_HTR_VOLT_HIGH_Q,
+	ERROR_HTR_VOLT_Q_HIGH_IMP,
+	ERROR_HTR_VOLT_LOW,
+	ERROR_HTR_FAILSAFE,
+	ERROR_AD_PULSE_LONG,
+	ERROR_AD_PULSE_SHORT,
+	ERROR_AD_RCAL_LONG,
+	ERROR_AD_RCAL_SHORT,
+	ERROR_AD_PTB_OVER,
+	ERROR_AD_PTB_UNDER,
+	ERROR_AD_TIMEOUT,
+	ERROR_CFG_XFER,
+	ERROR_CFG_SET_CRC,
+	ERROR_CFG_PROBE_CRC,
+	ERROR_CFG_CAL_CRC,
+	ERROR_CFG_LOG_CRC,
+	ERROR_CFG_NO_PROBE,
+	ERROR_CFG_UNIT_PROBE,
+	ERROR_CFG_ACK,
+	ERROR_CFG_INIT,
+	ERROR_BAT_HIGH,
+	ERROR_BAT_LOW,
+	ERROR_BAD_VIBES,
+	ERROR_NO_PROBE_WELL,
+	ERROR_POST_FAIL,
+	ERROR_INTERNAL_FAULT,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum hardwareState{
+	#[default]
+	probeConnected,
+	probePulled,
+	probeWellIn,
+	savingCal,
+	savingSettings,
+	takeReadingActive,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum method{
+	#[default]
+	PREDICT,
+	MONITOR,
+	CLINICAL,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum probeType{
+	#[default]
+	NO_PROBE,
+	ORAL,
+	RECTAL,
+	CALKEY,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum algorithm{
+	#[default]
+	NONE,
+	ORAL_ALG,
+	PED_AX_ALG,
+	ADULT_AX_ALG,
+	RECTAL_ALG,
+}
+
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmTEMP for CSTPDSample{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CSTPDSample{
+	channel:uint8,
+	error:uint8,
+	sample:uint32,
+	data:uint32,
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmTEMP for CTempDTouch{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CTempDTouch{
+	ele0:uint16,
+	ele1:uint16,
+	ele2:uint16,
+	touchstatus:uint16,
+	ele0bv:uint8,
+	ele1bv:uint8,
+	ele2bv:uint8,
+	hardwarestateir:hardwareStateIR,
+	samplecount:uint32,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum hardwareStateIR{
+	#[default]
+	TAKE_READING_ACTIVE,
+	PROBE_COVER_ON,
+}
+
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmTEMP for CTempDTherm{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CTempDTherm{
+	ambient:float,
+	ambient_count:int32,
+	thermopile:float,
+	thermopile_count:int32,
+	samplecount:uint32,
+	heaterpwm:int16,
+	heaterstate:heaterState,
+	heatererror:int16,
+	braun_ambient:float,
+	tcvalue:float,
+	pre_num:uint8,
+	post_num:uint8,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum heaterState{
+	#[default]
+	IDLE,
+	HEATER_TEST,
+	HEATER_ON,
+	READY,
+	ERROR,
+}
+
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmTEMP for CTempCStd{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CTempCStd{
+	enabled:boolean,
+	installedmodule:InstalledModule,
+	displayunits:DisplayUnits,
+	mode:Mode,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum InstalledModule{
+	#[default]
+	NONE,
+	UNKNOWN,
+	SURETEMP_SW,
+	SURETEMP,
+	SURETEMP_PLUS,
+	BRAUN_PRO4000,
+	BRAUN_PRO6000,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum DisplayUnits{
+	#[default]
+	DEG_F,
+	DEG_C,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum Mode{
+	#[default]
+	NONE,
+	UNKNOWN,
+	ORAL,
+	ADULT_AXIL,
+	PED_AXIL,
+	LAST,
+}
+
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmTEMP for CSTPCStd{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CSTPCStd{
+	clinicalpause:uint16,
+	devicetype:deviceType,
+	dfltalgorithm:dfltAlgorithm,
+	ambientbias:float,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum deviceType{
+	#[default]
+	PREDICT_DEVICE,
+	MONITOR_DEVICE,
+}
+
+#[derive(Clone,Copy,Debug,Default)]
+pub enum dfltAlgorithm{
+	#[default]
+	ORAL,
+	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() }
+}
+
+impl FmTEMP for CSTPCCal{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CSTPCCal{
+	signature:uint32,
+	datetime:chrono::NaiveDateTime,
+	modconfig:float,
+	yp0:float,
+	rp0:float,
+	rptbeff:float,
+	rcaleff:float,
+	vref:float,
+	#[getter(skip)]
+	raw_object:RawObject,
+}
+
+pub impl CSTPCCal {
+	fn new() -> Self { todo!() }
+}
+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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmTEMP for CTempPMsgArg{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CTempPMsgArg{
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+
+impl FmTEMP for CSTPPSelector{}
+#[derive(Getters,Builder,Clone,Debug)]
+pub struct CSTPPSelector{
+	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_raw_object(&self) -> RawObject { self.raw_object.clone() }
+}
+

src/main.rs

@@ -153,17 +153,6 @@ fn nested_parse(input_family:&mut oop::Family, node: roxmltree::Node, mut curren
                         .filter(|species| species.get_name().as_str() == current.attr_species)
                         .for_each(|species|{
                             current.attr_member = node.attribute("name").unwrap().to_string();
-                            let size:Option<usize>;
-                            match node.attribute("size"){
-                                None => size = None,
-                                Some(size_string) => {
-                                    if size_string == "UNBOUNDED" {
-                                        size = Some(usize::MAX);
-                                    } else {
-                                        size = Some(size_string.parse::<usize>().unwrap());
-                                    }
-                                },
-                            }
                                 species.get_objects().last_mut().unwrap().push_object_member(oop::ObjectMember::new(
                                     node.attribute("type").unwrap().to_string(),
                                     node.attribute("name").unwrap().to_string(),
@@ -171,8 +160,7 @@ fn nested_parse(input_family:&mut oop::Family, node: roxmltree::Node, mut curren
                                     node.attribute("minversion").unwrap().to_string(),
                                     node.attribute("maxversion").unwrap().to_string(),
                                     Vec::new(),
-                                    node.attribute("format").unwrap_or("").to_string(),
-                                    size
+                                    node.attribute("format").unwrap_or("").to_string()
                                 ));
                             
                         });
@@ -229,107 +217,115 @@ fn output_gen(family: oop::Family, output_path: String) -> (String, String){
                 "Species{\n"
             );
             for species_name in family.list_species() {
-                write_string.push_str(format!("\t{}\n",species_name).as_str());
+                write_string = format!(
+                    "{}{}{}{}",
+                    write_string, 
+                    "\t", 
+                    species_name, 
+                    ",\n"
+                );
             }
-            write_string.push_str(format!(
-                "}}\nimpl ObjectSpecies for {}Species{{}}\n\n",
-                family.get_name()
-            ).as_str());
+            write_string = format!(
+                "{}{}{}{}",
+                write_string,
+                "}\nimpl ObjectSpecies for ",
+                family.get_name().as_str(),
+                "Species{}\n\n"
+            );
             let mut genus_name:String;
             for genus in family.clone().get_genera() {
                 genus_name = genus.get_name();
                 for species in genus.get_species() {
                     for object in species.get_objects() {
-                        write_string.push_str(format!(
-                            "impl {} for {}{{}}\n#[derive(Getters,Builder,Clone,Debug)]\npub struct {}{{\n", 
+                        write_string = format!(
+                            "{}{}{}{}{}{}{}{}", 
+                            write_string,
+                            "impl ",
                             family.get_name(),
+                            " for ",
                             object.get_name(),
+                            "{}\n#[derive(Getters,Builder,Clone,Debug)]\npub struct ",
                             object.get_name(),
-                        ).as_str());
+                            "{\n"
+                        );
                         let mut enums = Vec::new();
                         for member in object.get_members() {
-                            match member.get_member_type().as_str(){
-                                "OBJECT" => {
-                                    write_string.push_str(format!(
-                                        "\t{}:&'static dyn Object,\n", 
+                            if member.get_member_type() != "OBJECT" {
+                                if member.get_member_type() == "TIME" {
+                                    write_string = format!(
+                                        "{}{}{}{}", 
+                                        write_string,
+                                        "\t",
                                         member.get_member_name().to_lowercase(),
-                                    ).as_str());
-                                },
-                                "TIME" => {
-                                    write_string.push_str(format!(
-                                        "\t{}:chrono::NaiveDateTime,\n",
-                                        member.get_member_name().to_lowercase())
-                                    .as_str());
-                                },
-                                "ansichar" | "widechar" => {
-                                    write_string.push_str(format!(
-                                        "\t{}:String,\n",
-                                        member.get_member_name().to_lowercase())
-                                    .as_str());
-                                },
-                                _ => {
-                                    write_string.push_str(format!(
-                                        "\t{}:", 
+                                        ":chrono::NaiveDateTime,\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(),
-                                    ).as_str());
-                                    if let Some(size_value) = member.get_size(){
-                                        if size_value == usize::MAX {
-                                            write_string.push_str("Vec<");
-                                        } else {
-                                            write_string.push_str("[");
-                                        }
-                                    }
-                                    if member.get_member_type().contains("uint"){
-                                        let mut fixed_type = member.get_member_type();
-                                        fixed_type.retain(|char| char.is_digit(10) || char == 'u' );
-                                        write_string.push_str(fixed_type.as_str());
-                                    } else if member.get_member_type().contains("int"){
-                                        let mut fixed_type = member.get_member_type();
-                                        fixed_type.retain(|char| char.is_digit(10) || char == 'i' );
-                                        write_string.push_str(fixed_type.as_str());
-                                    } else if member.get_member_type().contains("bool"){
-                                        write_string.push_str("bool");
-                                    } else if member.get_member_type().contains("float"){
-                                        write_string.push_str("f32");
-                                    } else { 
-                                        write_string.push_str(member.get_member_type().as_str()); 
-                                    }
-
-                                    if let Some(size_value) = member.get_size(){
-                                        if size_value == usize::MAX {
-                                            write_string.push_str(">,\n");
-                                        } else {
-                                            write_string.push_str(format!("; {},\n]",size_value).as_str());
-                                        }
-                                    } else {
-                                            write_string.push_str(",\n");
-                                    }
-                                },
+                                        ":",
+                                        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().to_lowercase(),
+                                    ":",
+                                    "Object",
+                                    "::",
+                                    member.get_member_class(),
+                                    ",\n"
+                                );
                             }
                             if !member.get_enumerations().is_empty() && member.get_enumerations().first().unwrap().get_name() != "" {
                                 enums.push(member)
                             }
                         }
-                        write_string.push_str("\t#[getter(skip)]\n\traw_object:RawObject,\n");
+                        write_string = format!(
+                            "{}{}",
+                            write_string,
+                            "\t#[getter(skip)]\n\traw_object:RawObject,\n"
+                        );
                         
                         if !enums.is_empty() {
                             for member in enums {
-                                write_string.push_str(format!(
-                                    "{}{}{}",
+                                write_string = format!(
+                                    "{}{}{}{}",
+                                    write_string,
                                     "}\n\n#[derive(Clone,Copy,Debug,Default)]\npub enum ",
                                     member.get_member_name(),
                                     "{\n\t#[default]\n"  
-                                ).as_str());
+                                );
                                 for e in member.get_enumerations() {
-                                    write_string.push_str(format!(
-                                        "\t{},\n",
+                                    write_string = format!(
+                                        "{}{}{}{}",
+                                        write_string,
+                                        "\t",
                                         e.get_name(),
-                                    ).as_str());
+                                        ",\n"
+                                    );
                                 }
                             }
                         }
-                        write_string.push_str(format!(
-                            "{}{}{}{}{}{}{}{}{}{}{}{}{}",
+                        write_string = format!(
+                            "{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
+                            write_string,
                             "}\n\nimpl ",
                             object.get_name(),
                             " {\n\tpub fn new() -> Self { todo!() }\n}\nimpl Object for ",
@@ -343,7 +339,7 @@ fn output_gen(family: oop::Family, output_path: String) -> (String, String){
                             "Species::",
                             object.get_name(),
                             ") }\n\tfn get_raw_object(&self) -> RawObject { self.raw_object.clone() }\n}\n\n"
-                        ).as_str());
+                        );
                     }
                 }
             }
@@ -368,19 +364,26 @@ fn output_gen(family: oop::Family, output_path: String) -> (String, String){
                 }
                 let mut message_num = 0x00;
                 for message in messages {
-                    write_string.push_str(format!(
-                        "\t{},\t\t\t//{} {}\n", 
+                    write_string = format!(
+                        "{}{}{}{}{}{}{}{}", 
+                        write_string, 
+                        "\t", 
                         message, 
+                        ",\t\t\t//", 
                         message_type, 
+                        " ", 
                         message_num, 
-                    ).as_str());
-                    message_num += 1;
+                        "\n"
+                    );
+                    message_num += 0x01;
                 }
             }
-            write_string.push_str(format!(
-                "}}\n\nimpl MessageSpecies for {}Message{{}} ", 
-                family.get_name().as_str(),
-            ).as_str());
+            write_string = format!(
+                "{}{}{}{}", 
+                write_string, 
+                "}\n\nimpl MessageSpecies for ", 
+                family.get_name().as_str(), "Message{}"
+            );
             
         },
         &_ => panic!("Output path format error")

src/oop.rs

@@ -2,7 +2,6 @@ use phf::phf_ordered_map;
 use crate::roxmltree::Node;
 use std::fmt;
 
-
 const MESSAGETYPE: phf::OrderedMap<&'static str, &'static str> = phf_ordered_map! {
     "Request" => "requests",
     "Response" => "responses",
@@ -174,23 +173,18 @@ pub struct ObjectMember {
     maxversion: String,
     enumerations: Vec<MemberEnumeration>,
     format: String,
-    size: Option<usize>,
 }
 
-#[allow(unused)]
 impl ObjectMember {
-    pub fn new(member_type: String, name: String, class: String, minversion: String, maxversion: String, enumerations: Vec<MemberEnumeration>, format: String, size: Option<usize>) -> Self {
-        Self { member_type, name, class, minversion, maxversion, enumerations, format, size }
-    }
-
-    pub fn get_size(&self) -> Option<usize>{
-        return self.size.clone()
+    pub fn new(member_type: String, name: String, class: String, minversion: String, maxversion: String, enumerations: Vec<MemberEnumeration>, format: String) -> Self {
+        Self { member_type, name, class, minversion, maxversion, enumerations, format }
     }
 
     pub fn get_member_name(&self) -> String{
         return self.name.clone()
     }
 
+    #[allow(unused)]
     pub fn get_member_type(&self) -> String{
         return self.member_type.clone()
     }
@@ -199,22 +193,27 @@ impl ObjectMember {
         return self.class.clone();
     }
 
+    #[allow(unused)]
     pub fn get_minversion(&self) -> String{
         return self.minversion.clone()
     }
 
+    #[allow(unused)]
     pub fn get_maxversion(&self) -> String{
         return self.maxversion.clone()
     }
 
+    #[allow(unused)]
     pub fn get_enumerations(&mut self) -> &mut Vec<MemberEnumeration>{
         return &mut self.enumerations
     }
 
+    #[allow(unused)]
     pub fn push_member_enumeration(&mut self, enumeration: MemberEnumeration) {
         self.enumerations.push(enumeration);
     }
 
+    #[allow(unused)]
     pub fn get_format(&self) -> Option<String>{
         if self.class != "" {
             return None;
@@ -330,4 +329,4 @@ impl Current {
             attr_species: "".to_string()
         }
     }
-}
+}