RustXMLParseTest/FmECG_objects.rs

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() }
}