diff --git a/src/ifcparse/Header_section_schema.cpp b/src/ifcparse/Header_section_schema.cpp
index cfc42e52ca..9ebdf79b82 100644
--- a/src/ifcparse/Header_section_schema.cpp
+++ b/src/ifcparse/Header_section_schema.cpp
@@ -18,10 +18,12 @@ extern declaration* HEADER_SECTION_SCHEMA_types[5];
 // Function implementations for schema_name
 const IfcParse::type_declaration& Header_section_schema::schema_name::Class() { return *((IfcParse::type_declaration*)HEADER_SECTION_SCHEMA_types[3]); }
 void Header_section_schema::schema_name::initialize(std::string v) { set_attribute_value(0, (v)); }
+Header_section_schema::schema_name::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for time_stamp_text
 const IfcParse::type_declaration& Header_section_schema::time_stamp_text::Class() { return *((IfcParse::type_declaration*)HEADER_SECTION_SCHEMA_types[4]); }
 void Header_section_schema::time_stamp_text::initialize(std::string v) { set_attribute_value(0, (v)); }
+Header_section_schema::time_stamp_text::operator std::string() const { return get_attribute_value(0); }
 
 
 // Function implementations for file_description
diff --git a/src/ifcparse/Ifc2x3.cpp b/src/ifcparse/Ifc2x3.cpp
index 0f0287b7ce..b978114735 100644
--- a/src/ifcparse/Ifc2x3.cpp
+++ b/src/ifcparse/Ifc2x3.cpp
@@ -4891,470 +4891,587 @@ const IfcParse::select_type& Ifc2x3::IfcVectorOrDirection::Class() { return *((I
 // Function implementations for IfcAbsorbedDoseMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcAbsorbedDoseMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[1]); }
 void Ifc2x3::IfcAbsorbedDoseMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcAbsorbedDoseMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAccelerationMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcAccelerationMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[2]); }
 void Ifc2x3::IfcAccelerationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcAccelerationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAmountOfSubstanceMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcAmountOfSubstanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[22]); }
 void Ifc2x3::IfcAmountOfSubstanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcAmountOfSubstanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAngularVelocityMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcAngularVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[26]); }
 void Ifc2x3::IfcAngularVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcAngularVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcAreaMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[47]); }
 void Ifc2x3::IfcAreaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcAreaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoolean
 const IfcParse::type_declaration& Ifc2x3::IfcBoolean::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[65]); }
 void Ifc2x3::IfcBoolean::initialize(bool v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcBoolean::operator bool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoxAlignment
 const IfcParse::type_declaration& Ifc2x3::IfcBoxAlignment::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[78]); }
+void Ifc2x3::IfcBoxAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc2x3::IfcBoxAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcComplexNumber
 const IfcParse::type_declaration& Ifc2x3::IfcComplexNumber::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[130]); }
 void Ifc2x3::IfcComplexNumber::initialize(std::vector< double > /*[1:2]*/ v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcComplexNumber::operator std::vector< double > /*[1:2]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCompoundPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcCompoundPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[135]); }
 void Ifc2x3::IfcCompoundPlaneAngleMeasure::initialize(std::vector< int > /*[3:4]*/ v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcCompoundPlaneAngleMeasure::operator std::vector< int > /*[3:4]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcContextDependentMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcContextDependentMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[161]); }
 void Ifc2x3::IfcContextDependentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcContextDependentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCountMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcCountMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[176]); }
 void Ifc2x3::IfcCountMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcCountMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCurvatureMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcCurvatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[192]); }
 void Ifc2x3::IfcCurvatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcCurvatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInMonthNumber
 const IfcParse::type_declaration& Ifc2x3::IfcDayInMonthNumber::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[207]); }
 void Ifc2x3::IfcDayInMonthNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcDayInMonthNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDaylightSavingHour
 const IfcParse::type_declaration& Ifc2x3::IfcDaylightSavingHour::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[208]); }
 void Ifc2x3::IfcDaylightSavingHour::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcDaylightSavingHour::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDescriptiveMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcDescriptiveMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[216]); }
 void Ifc2x3::IfcDescriptiveMeasure::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcDescriptiveMeasure::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDimensionCount
 const IfcParse::type_declaration& Ifc2x3::IfcDimensionCount::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[220]); }
 void Ifc2x3::IfcDimensionCount::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcDimensionCount::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDoseEquivalentMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcDoseEquivalentMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[255]); }
 void Ifc2x3::IfcDoseEquivalentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcDoseEquivalentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDynamicViscosityMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcDynamicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[268]); }
 void Ifc2x3::IfcDynamicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcDynamicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCapacitanceMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcElectricCapacitanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[278]); }
 void Ifc2x3::IfcElectricCapacitanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcElectricCapacitanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricChargeMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcElectricChargeMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[279]); }
 void Ifc2x3::IfcElectricChargeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcElectricChargeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricConductanceMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcElectricConductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[280]); }
 void Ifc2x3::IfcElectricConductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcElectricConductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCurrentMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcElectricCurrentMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[282]); }
 void Ifc2x3::IfcElectricCurrentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcElectricCurrentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricResistanceMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcElectricResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[293]); }
 void Ifc2x3::IfcElectricResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcElectricResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricVoltageMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcElectricVoltageMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[296]); }
 void Ifc2x3::IfcElectricVoltageMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcElectricVoltageMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcEnergyMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcEnergyMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[310]); }
 void Ifc2x3::IfcEnergyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcEnergyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontStyle
 const IfcParse::type_declaration& Ifc2x3::IfcFontStyle::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[373]); }
 void Ifc2x3::IfcFontStyle::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcFontStyle::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontVariant
 const IfcParse::type_declaration& Ifc2x3::IfcFontVariant::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[374]); }
 void Ifc2x3::IfcFontVariant::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcFontVariant::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontWeight
 const IfcParse::type_declaration& Ifc2x3::IfcFontWeight::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[375]); }
 void Ifc2x3::IfcFontWeight::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcFontWeight::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcForceMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[378]); }
 void Ifc2x3::IfcForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFrequencyMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[379]); }
 void Ifc2x3::IfcFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcGloballyUniqueId
 const IfcParse::type_declaration& Ifc2x3::IfcGloballyUniqueId::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[396]); }
 void Ifc2x3::IfcGloballyUniqueId::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcGloballyUniqueId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatFluxDensityMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcHeatFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[406]); }
 void Ifc2x3::IfcHeatFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcHeatFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatingValueMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcHeatingValueMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[407]); }
 void Ifc2x3::IfcHeatingValueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcHeatingValueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHourInDay
 const IfcParse::type_declaration& Ifc2x3::IfcHourInDay::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[408]); }
 void Ifc2x3::IfcHourInDay::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcHourInDay::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIdentifier
 const IfcParse::type_declaration& Ifc2x3::IfcIdentifier::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[412]); }
 void Ifc2x3::IfcIdentifier::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcIdentifier::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIlluminanceMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcIlluminanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[413]); }
 void Ifc2x3::IfcIlluminanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcIlluminanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInductanceMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcInductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[415]); }
 void Ifc2x3::IfcInductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcInductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInteger
 const IfcParse::type_declaration& Ifc2x3::IfcInteger::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[416]); }
 void Ifc2x3::IfcInteger::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIntegerCountRateMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcIntegerCountRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[417]); }
 void Ifc2x3::IfcIntegerCountRateMeasure::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcIntegerCountRateMeasure::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIonConcentrationMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcIonConcentrationMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[421]); }
 void Ifc2x3::IfcIonConcentrationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcIonConcentrationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIsothermalMoistureCapacityMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcIsothermalMoistureCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[425]); }
 void Ifc2x3::IfcIsothermalMoistureCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcIsothermalMoistureCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcKinematicViscosityMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcKinematicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[428]); }
 void Ifc2x3::IfcKinematicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcKinematicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLabel
 const IfcParse::type_declaration& Ifc2x3::IfcLabel::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[429]); }
 void Ifc2x3::IfcLabel::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcLabel::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLengthMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[435]); }
 void Ifc2x3::IfcLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearForceMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcLinearForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[454]); }
 void Ifc2x3::IfcLinearForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcLinearForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearMomentMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcLinearMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[455]); }
 void Ifc2x3::IfcLinearMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcLinearMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearStiffnessMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcLinearStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[456]); }
 void Ifc2x3::IfcLinearStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcLinearStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearVelocityMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcLinearVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[457]); }
 void Ifc2x3::IfcLinearVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcLinearVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLogical
 const IfcParse::type_declaration& Ifc2x3::IfcLogical::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[461]); }
 void Ifc2x3::IfcLogical::initialize(boost::logic::tribool v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcLogical::operator boost::logic::tribool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousFluxMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcLuminousFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[465]); }
 void Ifc2x3::IfcLuminousFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcLuminousFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityDistributionMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcLuminousIntensityDistributionMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[466]); }
 void Ifc2x3::IfcLuminousIntensityDistributionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcLuminousIntensityDistributionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcLuminousIntensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[467]); }
 void Ifc2x3::IfcLuminousIntensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcLuminousIntensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxDensityMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcMagneticFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[468]); }
 void Ifc2x3::IfcMagneticFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcMagneticFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcMagneticFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[469]); }
 void Ifc2x3::IfcMagneticFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcMagneticFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassDensityMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcMassDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[472]); }
 void Ifc2x3::IfcMassDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcMassDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassFlowRateMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcMassFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[473]); }
 void Ifc2x3::IfcMassFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcMassFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[474]); }
 void Ifc2x3::IfcMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassPerLengthMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcMassPerLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[475]); }
 void Ifc2x3::IfcMassPerLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcMassPerLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMinuteInHour
 const IfcParse::type_declaration& Ifc2x3::IfcMinuteInHour::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[497]); }
 void Ifc2x3::IfcMinuteInHour::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcMinuteInHour::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfElasticityMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcModulusOfElasticityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[498]); }
 void Ifc2x3::IfcModulusOfElasticityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcModulusOfElasticityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfLinearSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcModulusOfLinearSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[499]); }
 void Ifc2x3::IfcModulusOfLinearSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcModulusOfLinearSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfRotationalSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcModulusOfRotationalSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[500]); }
 void Ifc2x3::IfcModulusOfRotationalSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcModulusOfRotationalSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcModulusOfSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[501]); }
 void Ifc2x3::IfcModulusOfSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcModulusOfSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMoistureDiffusivityMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcMoistureDiffusivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[502]); }
 void Ifc2x3::IfcMoistureDiffusivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcMoistureDiffusivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMolecularWeightMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcMolecularWeightMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[503]); }
 void Ifc2x3::IfcMolecularWeightMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcMolecularWeightMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMomentOfInertiaMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcMomentOfInertiaMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[504]); }
 void Ifc2x3::IfcMomentOfInertiaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcMomentOfInertiaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonetaryMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcMonetaryMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[505]); }
 void Ifc2x3::IfcMonetaryMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcMonetaryMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonthInYearNumber
 const IfcParse::type_declaration& Ifc2x3::IfcMonthInYearNumber::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[507]); }
 void Ifc2x3::IfcMonthInYearNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcMonthInYearNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNormalisedRatioMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcNormalisedRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[512]); }
+void Ifc2x3::IfcNormalisedRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc2x3::IfcNormalisedRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNumericMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcNumericMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[514]); }
 void Ifc2x3::IfcNumericMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcNumericMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPHMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcPHMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[547]); }
 void Ifc2x3::IfcPHMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcPHMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcParameterValue
 const IfcParse::type_declaration& Ifc2x3::IfcParameterValue::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[539]); }
 void Ifc2x3::IfcParameterValue::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcParameterValue::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlanarForceMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcPlanarForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[563]); }
 void Ifc2x3::IfcPlanarForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcPlanarForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[565]); }
 void Ifc2x3::IfcPlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcPlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveLengthMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcPositiveLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[577]); }
+void Ifc2x3::IfcPositiveLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc2x3::IfcPositiveLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositivePlaneAngleMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcPositivePlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[578]); }
+void Ifc2x3::IfcPositivePlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc2x3::IfcPositivePlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveRatioMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcPositiveRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[579]); }
+void Ifc2x3::IfcPositiveRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc2x3::IfcPositiveRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPowerMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[581]); }
 void Ifc2x3::IfcPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPresentableText
 const IfcParse::type_declaration& Ifc2x3::IfcPresentableText::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[590]); }
 void Ifc2x3::IfcPresentableText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcPresentableText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPressureMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[596]); }
 void Ifc2x3::IfcPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRadioActivityMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcRadioActivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[640]); }
 void Ifc2x3::IfcRadioActivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcRadioActivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRatioMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[650]); }
 void Ifc2x3::IfcRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcReal
 const IfcParse::type_declaration& Ifc2x3::IfcReal::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[652]); }
 void Ifc2x3::IfcReal::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcReal::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalFrequencyMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcRotationalFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[733]); }
 void Ifc2x3::IfcRotationalFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcRotationalFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalMassMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcRotationalMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[734]); }
 void Ifc2x3::IfcRotationalMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcRotationalMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalStiffnessMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcRotationalStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[735]); }
 void Ifc2x3::IfcRotationalStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcRotationalStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSecondInMinute
 const IfcParse::type_declaration& Ifc2x3::IfcSecondInMinute::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[741]); }
 void Ifc2x3::IfcSecondInMinute::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcSecondInMinute::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionModulusMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcSectionModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[744]); }
 void Ifc2x3::IfcSectionModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcSectionModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionalAreaIntegralMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcSectionalAreaIntegralMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[742]); }
 void Ifc2x3::IfcSectionalAreaIntegralMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcSectionalAreaIntegralMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcShearModulusMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcShearModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[758]); }
 void Ifc2x3::IfcShearModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcShearModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSolidAngleMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcSolidAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[772]); }
 void Ifc2x3::IfcSolidAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcSolidAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcSoundPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[774]); }
 void Ifc2x3::IfcSoundPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcSoundPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcSoundPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[775]); }
 void Ifc2x3::IfcSoundPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcSoundPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecificHeatCapacityMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcSpecificHeatCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[788]); }
 void Ifc2x3::IfcSpecificHeatCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcSpecificHeatCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularExponent
 const IfcParse::type_declaration& Ifc2x3::IfcSpecularExponent::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[789]); }
 void Ifc2x3::IfcSpecularExponent::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcSpecularExponent::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularRoughness
 const IfcParse::type_declaration& Ifc2x3::IfcSpecularRoughness::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[791]); }
 void Ifc2x3::IfcSpecularRoughness::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcSpecularRoughness::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureGradientMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcTemperatureGradientMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[874]); }
 void Ifc2x3::IfcTemperatureGradientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcTemperatureGradientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcText
 const IfcParse::type_declaration& Ifc2x3::IfcText::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[879]); }
 void Ifc2x3::IfcText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextAlignment
 const IfcParse::type_declaration& Ifc2x3::IfcTextAlignment::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[880]); }
 void Ifc2x3::IfcTextAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcTextAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextDecoration
 const IfcParse::type_declaration& Ifc2x3::IfcTextDecoration::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[881]); }
 void Ifc2x3::IfcTextDecoration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcTextDecoration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextFontName
 const IfcParse::type_declaration& Ifc2x3::IfcTextFontName::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[882]); }
 void Ifc2x3::IfcTextFontName::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcTextFontName::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextTransformation
 const IfcParse::type_declaration& Ifc2x3::IfcTextTransformation::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[893]); }
 void Ifc2x3::IfcTextTransformation::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcTextTransformation::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalAdmittanceMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcThermalAdmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[898]); }
 void Ifc2x3::IfcThermalAdmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcThermalAdmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalConductivityMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcThermalConductivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[899]); }
 void Ifc2x3::IfcThermalConductivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcThermalConductivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalExpansionCoefficientMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcThermalExpansionCoefficientMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[900]); }
 void Ifc2x3::IfcThermalExpansionCoefficientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcThermalExpansionCoefficientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalResistanceMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcThermalResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[904]); }
 void Ifc2x3::IfcThermalResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcThermalResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalTransmittanceMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcThermalTransmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[905]); }
 void Ifc2x3::IfcThermalTransmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcThermalTransmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermodynamicTemperatureMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcThermodynamicTemperatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[906]); }
 void Ifc2x3::IfcThermodynamicTemperatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcThermodynamicTemperatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcTimeMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[907]); }
 void Ifc2x3::IfcTimeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcTimeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeStamp
 const IfcParse::type_declaration& Ifc2x3::IfcTimeStamp::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[914]); }
 void Ifc2x3::IfcTimeStamp::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcTimeStamp::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTorqueMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcTorqueMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[917]); }
 void Ifc2x3::IfcTorqueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcTorqueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVaporPermeabilityMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcVaporPermeabilityMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[943]); }
 void Ifc2x3::IfcVaporPermeabilityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcVaporPermeabilityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumeMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcVolumeMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[954]); }
 void Ifc2x3::IfcVolumeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcVolumeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumetricFlowRateMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcVolumetricFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[955]); }
 void Ifc2x3::IfcVolumetricFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcVolumetricFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingConstantMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcWarpingConstantMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[960]); }
 void Ifc2x3::IfcWarpingConstantMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcWarpingConstantMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingMomentMeasure
 const IfcParse::type_declaration& Ifc2x3::IfcWarpingMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[961]); }
 void Ifc2x3::IfcWarpingMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcWarpingMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcYearNumber
 const IfcParse::type_declaration& Ifc2x3::IfcYearNumber::Class() { return *((IfcParse::type_declaration*)IFC2X3_types[977]); }
 void Ifc2x3::IfcYearNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc2x3::IfcYearNumber::operator int() const { return get_attribute_value(0); }
 
 
 // Function implementations for Ifc2DCompositeCurve
diff --git a/src/ifcparse/Ifc4.cpp b/src/ifcparse/Ifc4.cpp
index 226c89cde8..4c7218cfa9 100644
--- a/src/ifcparse/Ifc4.cpp
+++ b/src/ifcparse/Ifc4.cpp
@@ -6166,522 +6166,652 @@ const IfcParse::select_type& Ifc4::IfcWarpingStiffnessSelect::Class() { return *
 // Function implementations for IfcAbsorbedDoseMeasure
 const IfcParse::type_declaration& Ifc4::IfcAbsorbedDoseMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[0]); }
 void Ifc4::IfcAbsorbedDoseMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcAbsorbedDoseMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAccelerationMeasure
 const IfcParse::type_declaration& Ifc4::IfcAccelerationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1]); }
 void Ifc4::IfcAccelerationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcAccelerationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAmountOfSubstanceMeasure
 const IfcParse::type_declaration& Ifc4::IfcAmountOfSubstanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[29]); }
 void Ifc4::IfcAmountOfSubstanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcAmountOfSubstanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAngularVelocityMeasure
 const IfcParse::type_declaration& Ifc4::IfcAngularVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[32]); }
 void Ifc4::IfcAngularVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcAngularVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcArcIndex
 const IfcParse::type_declaration& Ifc4::IfcArcIndex::Class() { return *((IfcParse::type_declaration*)IFC4_types[43]); }
 void Ifc4::IfcArcIndex::initialize(std::vector< int > /*[3:3]*/ v) { set_attribute_value(0, (v)); }
+Ifc4::IfcArcIndex::operator std::vector< int > /*[3:3]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaDensityMeasure
 const IfcParse::type_declaration& Ifc4::IfcAreaDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[44]); }
 void Ifc4::IfcAreaDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcAreaDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaMeasure
 const IfcParse::type_declaration& Ifc4::IfcAreaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[45]); }
 void Ifc4::IfcAreaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcAreaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBinary
 const IfcParse::type_declaration& Ifc4::IfcBinary::Class() { return *((IfcParse::type_declaration*)IFC4_types[63]); }
 void Ifc4::IfcBinary::initialize(boost::dynamic_bitset<> v) { set_attribute_value(0, (v)); }
+Ifc4::IfcBinary::operator boost::dynamic_bitset<>() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoolean
 const IfcParse::type_declaration& Ifc4::IfcBoolean::Class() { return *((IfcParse::type_declaration*)IFC4_types[69]); }
 void Ifc4::IfcBoolean::initialize(bool v) { set_attribute_value(0, (v)); }
+Ifc4::IfcBoolean::operator bool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoxAlignment
 const IfcParse::type_declaration& Ifc4::IfcBoxAlignment::Class() { return *((IfcParse::type_declaration*)IFC4_types[83]); }
+void Ifc4::IfcBoxAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4::IfcBoxAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCardinalPointReference
 const IfcParse::type_declaration& Ifc4::IfcCardinalPointReference::Class() { return *((IfcParse::type_declaration*)IFC4_types[118]); }
 void Ifc4::IfcCardinalPointReference::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4::IfcCardinalPointReference::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcComplexNumber
 const IfcParse::type_declaration& Ifc4::IfcComplexNumber::Class() { return *((IfcParse::type_declaration*)IFC4_types[161]); }
 void Ifc4::IfcComplexNumber::initialize(std::vector< double > /*[1:2]*/ v) { set_attribute_value(0, (v)); }
+Ifc4::IfcComplexNumber::operator std::vector< double > /*[1:2]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCompoundPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4::IfcCompoundPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[169]); }
 void Ifc4::IfcCompoundPlaneAngleMeasure::initialize(std::vector< int > /*[3:4]*/ v) { set_attribute_value(0, (v)); }
+Ifc4::IfcCompoundPlaneAngleMeasure::operator std::vector< int > /*[3:4]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcContextDependentMeasure
 const IfcParse::type_declaration& Ifc4::IfcContextDependentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[199]); }
 void Ifc4::IfcContextDependentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcContextDependentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCountMeasure
 const IfcParse::type_declaration& Ifc4::IfcCountMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[221]); }
 void Ifc4::IfcCountMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcCountMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCurvatureMeasure
 const IfcParse::type_declaration& Ifc4::IfcCurvatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[236]); }
 void Ifc4::IfcCurvatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcCurvatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDate
 const IfcParse::type_declaration& Ifc4::IfcDate::Class() { return *((IfcParse::type_declaration*)IFC4_types[254]); }
 void Ifc4::IfcDate::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4::IfcDate::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDateTime
 const IfcParse::type_declaration& Ifc4::IfcDateTime::Class() { return *((IfcParse::type_declaration*)IFC4_types[255]); }
 void Ifc4::IfcDateTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4::IfcDateTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInMonthNumber
 const IfcParse::type_declaration& Ifc4::IfcDayInMonthNumber::Class() { return *((IfcParse::type_declaration*)IFC4_types[256]); }
 void Ifc4::IfcDayInMonthNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4::IfcDayInMonthNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInWeekNumber
 const IfcParse::type_declaration& Ifc4::IfcDayInWeekNumber::Class() { return *((IfcParse::type_declaration*)IFC4_types[257]); }
 void Ifc4::IfcDayInWeekNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4::IfcDayInWeekNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDescriptiveMeasure
 const IfcParse::type_declaration& Ifc4::IfcDescriptiveMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[264]); }
 void Ifc4::IfcDescriptiveMeasure::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4::IfcDescriptiveMeasure::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDimensionCount
 const IfcParse::type_declaration& Ifc4::IfcDimensionCount::Class() { return *((IfcParse::type_declaration*)IFC4_types[266]); }
 void Ifc4::IfcDimensionCount::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4::IfcDimensionCount::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDoseEquivalentMeasure
 const IfcParse::type_declaration& Ifc4::IfcDoseEquivalentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[304]); }
 void Ifc4::IfcDoseEquivalentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcDoseEquivalentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDuration
 const IfcParse::type_declaration& Ifc4::IfcDuration::Class() { return *((IfcParse::type_declaration*)IFC4_types[316]); }
 void Ifc4::IfcDuration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4::IfcDuration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDynamicViscosityMeasure
 const IfcParse::type_declaration& Ifc4::IfcDynamicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[317]); }
 void Ifc4::IfcDynamicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcDynamicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCapacitanceMeasure
 const IfcParse::type_declaration& Ifc4::IfcElectricCapacitanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[324]); }
 void Ifc4::IfcElectricCapacitanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcElectricCapacitanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricChargeMeasure
 const IfcParse::type_declaration& Ifc4::IfcElectricChargeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[325]); }
 void Ifc4::IfcElectricChargeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcElectricChargeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricConductanceMeasure
 const IfcParse::type_declaration& Ifc4::IfcElectricConductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[326]); }
 void Ifc4::IfcElectricConductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcElectricConductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCurrentMeasure
 const IfcParse::type_declaration& Ifc4::IfcElectricCurrentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[327]); }
 void Ifc4::IfcElectricCurrentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcElectricCurrentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricResistanceMeasure
 const IfcParse::type_declaration& Ifc4::IfcElectricResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[340]); }
 void Ifc4::IfcElectricResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcElectricResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricVoltageMeasure
 const IfcParse::type_declaration& Ifc4::IfcElectricVoltageMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[344]); }
 void Ifc4::IfcElectricVoltageMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcElectricVoltageMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcEnergyMeasure
 const IfcParse::type_declaration& Ifc4::IfcEnergyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[359]); }
 void Ifc4::IfcEnergyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcEnergyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontStyle
 const IfcParse::type_declaration& Ifc4::IfcFontStyle::Class() { return *((IfcParse::type_declaration*)IFC4_types[435]); }
 void Ifc4::IfcFontStyle::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4::IfcFontStyle::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontVariant
 const IfcParse::type_declaration& Ifc4::IfcFontVariant::Class() { return *((IfcParse::type_declaration*)IFC4_types[436]); }
 void Ifc4::IfcFontVariant::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4::IfcFontVariant::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontWeight
 const IfcParse::type_declaration& Ifc4::IfcFontWeight::Class() { return *((IfcParse::type_declaration*)IFC4_types[437]); }
 void Ifc4::IfcFontWeight::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4::IfcFontWeight::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcForceMeasure
 const IfcParse::type_declaration& Ifc4::IfcForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[441]); }
 void Ifc4::IfcForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFrequencyMeasure
 const IfcParse::type_declaration& Ifc4::IfcFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[442]); }
 void Ifc4::IfcFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcGloballyUniqueId
 const IfcParse::type_declaration& Ifc4::IfcGloballyUniqueId::Class() { return *((IfcParse::type_declaration*)IFC4_types[458]); }
 void Ifc4::IfcGloballyUniqueId::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4::IfcGloballyUniqueId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4::IfcHeatFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[471]); }
 void Ifc4::IfcHeatFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcHeatFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatingValueMeasure
 const IfcParse::type_declaration& Ifc4::IfcHeatingValueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[472]); }
 void Ifc4::IfcHeatingValueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcHeatingValueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIdentifier
 const IfcParse::type_declaration& Ifc4::IfcIdentifier::Class() { return *((IfcParse::type_declaration*)IFC4_types[476]); }
 void Ifc4::IfcIdentifier::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4::IfcIdentifier::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIlluminanceMeasure
 const IfcParse::type_declaration& Ifc4::IfcIlluminanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[477]); }
 void Ifc4::IfcIlluminanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcIlluminanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInductanceMeasure
 const IfcParse::type_declaration& Ifc4::IfcInductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[485]); }
 void Ifc4::IfcInductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcInductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInteger
 const IfcParse::type_declaration& Ifc4::IfcInteger::Class() { return *((IfcParse::type_declaration*)IFC4_types[486]); }
 void Ifc4::IfcInteger::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4::IfcInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIntegerCountRateMeasure
 const IfcParse::type_declaration& Ifc4::IfcIntegerCountRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[487]); }
 void Ifc4::IfcIntegerCountRateMeasure::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4::IfcIntegerCountRateMeasure::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIonConcentrationMeasure
 const IfcParse::type_declaration& Ifc4::IfcIonConcentrationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[495]); }
 void Ifc4::IfcIonConcentrationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcIonConcentrationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIsothermalMoistureCapacityMeasure
 const IfcParse::type_declaration& Ifc4::IfcIsothermalMoistureCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[499]); }
 void Ifc4::IfcIsothermalMoistureCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcIsothermalMoistureCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcKinematicViscosityMeasure
 const IfcParse::type_declaration& Ifc4::IfcKinematicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[503]); }
 void Ifc4::IfcKinematicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcKinematicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLabel
 const IfcParse::type_declaration& Ifc4::IfcLabel::Class() { return *((IfcParse::type_declaration*)IFC4_types[505]); }
 void Ifc4::IfcLabel::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4::IfcLabel::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLanguageId
 const IfcParse::type_declaration& Ifc4::IfcLanguageId::Class() { return *((IfcParse::type_declaration*)IFC4_types[513]); }
+void Ifc4::IfcLanguageId::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4::IfcLanguageId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLengthMeasure
 const IfcParse::type_declaration& Ifc4::IfcLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[516]); }
 void Ifc4::IfcLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLineIndex
 const IfcParse::type_declaration& Ifc4::IfcLineIndex::Class() { return *((IfcParse::type_declaration*)IFC4_types[539]); }
 void Ifc4::IfcLineIndex::initialize(std::vector< int > /*[2:?]*/ v) { set_attribute_value(0, (v)); }
+Ifc4::IfcLineIndex::operator std::vector< int > /*[2:?]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearForceMeasure
 const IfcParse::type_declaration& Ifc4::IfcLinearForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[535]); }
 void Ifc4::IfcLinearForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcLinearForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearMomentMeasure
 const IfcParse::type_declaration& Ifc4::IfcLinearMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[536]); }
 void Ifc4::IfcLinearMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcLinearMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearStiffnessMeasure
 const IfcParse::type_declaration& Ifc4::IfcLinearStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[537]); }
 void Ifc4::IfcLinearStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcLinearStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearVelocityMeasure
 const IfcParse::type_declaration& Ifc4::IfcLinearVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[538]); }
 void Ifc4::IfcLinearVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcLinearVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLogical
 const IfcParse::type_declaration& Ifc4::IfcLogical::Class() { return *((IfcParse::type_declaration*)IFC4_types[542]); }
 void Ifc4::IfcLogical::initialize(boost::logic::tribool v) { set_attribute_value(0, (v)); }
+Ifc4::IfcLogical::operator boost::logic::tribool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousFluxMeasure
 const IfcParse::type_declaration& Ifc4::IfcLuminousFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[546]); }
 void Ifc4::IfcLuminousFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcLuminousFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityDistributionMeasure
 const IfcParse::type_declaration& Ifc4::IfcLuminousIntensityDistributionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[547]); }
 void Ifc4::IfcLuminousIntensityDistributionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcLuminousIntensityDistributionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityMeasure
 const IfcParse::type_declaration& Ifc4::IfcLuminousIntensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[548]); }
 void Ifc4::IfcLuminousIntensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcLuminousIntensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4::IfcMagneticFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[549]); }
 void Ifc4::IfcMagneticFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcMagneticFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxMeasure
 const IfcParse::type_declaration& Ifc4::IfcMagneticFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[550]); }
 void Ifc4::IfcMagneticFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcMagneticFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassDensityMeasure
 const IfcParse::type_declaration& Ifc4::IfcMassDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[554]); }
 void Ifc4::IfcMassDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcMassDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassFlowRateMeasure
 const IfcParse::type_declaration& Ifc4::IfcMassFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[555]); }
 void Ifc4::IfcMassFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcMassFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassMeasure
 const IfcParse::type_declaration& Ifc4::IfcMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[556]); }
 void Ifc4::IfcMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassPerLengthMeasure
 const IfcParse::type_declaration& Ifc4::IfcMassPerLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[557]); }
 void Ifc4::IfcMassPerLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcMassPerLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfElasticityMeasure
 const IfcParse::type_declaration& Ifc4::IfcModulusOfElasticityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[593]); }
 void Ifc4::IfcModulusOfElasticityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcModulusOfElasticityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfLinearSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4::IfcModulusOfLinearSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[594]); }
 void Ifc4::IfcModulusOfLinearSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcModulusOfLinearSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfRotationalSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4::IfcModulusOfRotationalSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[595]); }
 void Ifc4::IfcModulusOfRotationalSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcModulusOfRotationalSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4::IfcModulusOfSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[597]); }
 void Ifc4::IfcModulusOfSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcModulusOfSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMoistureDiffusivityMeasure
 const IfcParse::type_declaration& Ifc4::IfcMoistureDiffusivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[600]); }
 void Ifc4::IfcMoistureDiffusivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcMoistureDiffusivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMolecularWeightMeasure
 const IfcParse::type_declaration& Ifc4::IfcMolecularWeightMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[601]); }
 void Ifc4::IfcMolecularWeightMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcMolecularWeightMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMomentOfInertiaMeasure
 const IfcParse::type_declaration& Ifc4::IfcMomentOfInertiaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[602]); }
 void Ifc4::IfcMomentOfInertiaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcMomentOfInertiaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonetaryMeasure
 const IfcParse::type_declaration& Ifc4::IfcMonetaryMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[603]); }
 void Ifc4::IfcMonetaryMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcMonetaryMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonthInYearNumber
 const IfcParse::type_declaration& Ifc4::IfcMonthInYearNumber::Class() { return *((IfcParse::type_declaration*)IFC4_types[605]); }
 void Ifc4::IfcMonthInYearNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4::IfcMonthInYearNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNonNegativeLengthMeasure
 const IfcParse::type_declaration& Ifc4::IfcNonNegativeLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[610]); }
+void Ifc4::IfcNonNegativeLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4::IfcNonNegativeLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNormalisedRatioMeasure
 const IfcParse::type_declaration& Ifc4::IfcNormalisedRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[611]); }
+void Ifc4::IfcNormalisedRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4::IfcNormalisedRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNumericMeasure
 const IfcParse::type_declaration& Ifc4::IfcNumericMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[613]); }
 void Ifc4::IfcNumericMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcNumericMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPHMeasure
 const IfcParse::type_declaration& Ifc4::IfcPHMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[649]); }
 void Ifc4::IfcPHMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcPHMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcParameterValue
 const IfcParse::type_declaration& Ifc4::IfcParameterValue::Class() { return *((IfcParse::type_declaration*)IFC4_types[638]); }
 void Ifc4::IfcParameterValue::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcParameterValue::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlanarForceMeasure
 const IfcParse::type_declaration& Ifc4::IfcPlanarForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[668]); }
 void Ifc4::IfcPlanarForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcPlanarForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4::IfcPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[670]); }
 void Ifc4::IfcPlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcPlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveInteger
 const IfcParse::type_declaration& Ifc4::IfcPositiveInteger::Class() { return *((IfcParse::type_declaration*)IFC4_types[684]); }
+void Ifc4::IfcPositiveInteger::initialize(int v) { set_attribute_value(0, (v)); }
 Ifc4::IfcPositiveInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveLengthMeasure
 const IfcParse::type_declaration& Ifc4::IfcPositiveLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[685]); }
+void Ifc4::IfcPositiveLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4::IfcPositiveLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositivePlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4::IfcPositivePlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[686]); }
+void Ifc4::IfcPositivePlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4::IfcPositivePlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveRatioMeasure
 const IfcParse::type_declaration& Ifc4::IfcPositiveRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[687]); }
+void Ifc4::IfcPositiveRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4::IfcPositiveRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPowerMeasure
 const IfcParse::type_declaration& Ifc4::IfcPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[689]); }
 void Ifc4::IfcPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPresentableText
 const IfcParse::type_declaration& Ifc4::IfcPresentableText::Class() { return *((IfcParse::type_declaration*)IFC4_types[697]); }
 void Ifc4::IfcPresentableText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4::IfcPresentableText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPressureMeasure
 const IfcParse::type_declaration& Ifc4::IfcPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[704]); }
 void Ifc4::IfcPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPropertySetDefinitionSet
 const IfcParse::type_declaration& Ifc4::IfcPropertySetDefinitionSet::Class() { return *((IfcParse::type_declaration*)IFC4_types[738]); }
 void Ifc4::IfcPropertySetDefinitionSet::initialize(std::vector< ::Ifc4::IfcPropertySetDefinition > v) { set_attribute_value(0, cast_vector<express::Base>(v)); }
+Ifc4::IfcPropertySetDefinitionSet::operator std::vector< ::Ifc4::IfcPropertySetDefinition >() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4::IfcPropertySetDefinition>(es); }
 
 // Function implementations for IfcRadioActivityMeasure
 const IfcParse::type_declaration& Ifc4::IfcRadioActivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[762]); }
 void Ifc4::IfcRadioActivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcRadioActivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRatioMeasure
 const IfcParse::type_declaration& Ifc4::IfcRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[772]); }
 void Ifc4::IfcRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcReal
 const IfcParse::type_declaration& Ifc4::IfcReal::Class() { return *((IfcParse::type_declaration*)IFC4_types[775]); }
 void Ifc4::IfcReal::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcReal::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalFrequencyMeasure
 const IfcParse::type_declaration& Ifc4::IfcRotationalFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[866]); }
 void Ifc4::IfcRotationalFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcRotationalFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalMassMeasure
 const IfcParse::type_declaration& Ifc4::IfcRotationalMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[867]); }
 void Ifc4::IfcRotationalMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcRotationalMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalStiffnessMeasure
 const IfcParse::type_declaration& Ifc4::IfcRotationalStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[868]); }
 void Ifc4::IfcRotationalStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcRotationalStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionModulusMeasure
 const IfcParse::type_declaration& Ifc4::IfcSectionModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[878]); }
 void Ifc4::IfcSectionModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcSectionModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionalAreaIntegralMeasure
 const IfcParse::type_declaration& Ifc4::IfcSectionalAreaIntegralMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[876]); }
 void Ifc4::IfcSectionalAreaIntegralMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcSectionalAreaIntegralMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcShearModulusMeasure
 const IfcParse::type_declaration& Ifc4::IfcShearModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[893]); }
 void Ifc4::IfcShearModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcShearModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSolidAngleMeasure
 const IfcParse::type_declaration& Ifc4::IfcSolidAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[914]); }
 void Ifc4::IfcSolidAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcSolidAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerLevelMeasure
 const IfcParse::type_declaration& Ifc4::IfcSoundPowerLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[917]); }
 void Ifc4::IfcSoundPowerLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcSoundPowerLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerMeasure
 const IfcParse::type_declaration& Ifc4::IfcSoundPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[918]); }
 void Ifc4::IfcSoundPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcSoundPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureLevelMeasure
 const IfcParse::type_declaration& Ifc4::IfcSoundPressureLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[919]); }
 void Ifc4::IfcSoundPressureLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcSoundPressureLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureMeasure
 const IfcParse::type_declaration& Ifc4::IfcSoundPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[920]); }
 void Ifc4::IfcSoundPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcSoundPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecificHeatCapacityMeasure
 const IfcParse::type_declaration& Ifc4::IfcSpecificHeatCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[935]); }
 void Ifc4::IfcSpecificHeatCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcSpecificHeatCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularExponent
 const IfcParse::type_declaration& Ifc4::IfcSpecularExponent::Class() { return *((IfcParse::type_declaration*)IFC4_types[936]); }
 void Ifc4::IfcSpecularExponent::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcSpecularExponent::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularRoughness
 const IfcParse::type_declaration& Ifc4::IfcSpecularRoughness::Class() { return *((IfcParse::type_declaration*)IFC4_types[938]); }
 void Ifc4::IfcSpecularRoughness::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcSpecularRoughness::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureGradientMeasure
 const IfcParse::type_declaration& Ifc4::IfcTemperatureGradientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1043]); }
 void Ifc4::IfcTemperatureGradientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcTemperatureGradientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureRateOfChangeMeasure
 const IfcParse::type_declaration& Ifc4::IfcTemperatureRateOfChangeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1044]); }
 void Ifc4::IfcTemperatureRateOfChangeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcTemperatureRateOfChangeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcText
 const IfcParse::type_declaration& Ifc4::IfcText::Class() { return *((IfcParse::type_declaration*)IFC4_types[1053]); }
 void Ifc4::IfcText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4::IfcText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextAlignment
 const IfcParse::type_declaration& Ifc4::IfcTextAlignment::Class() { return *((IfcParse::type_declaration*)IFC4_types[1054]); }
 void Ifc4::IfcTextAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4::IfcTextAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextDecoration
 const IfcParse::type_declaration& Ifc4::IfcTextDecoration::Class() { return *((IfcParse::type_declaration*)IFC4_types[1055]); }
 void Ifc4::IfcTextDecoration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4::IfcTextDecoration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextFontName
 const IfcParse::type_declaration& Ifc4::IfcTextFontName::Class() { return *((IfcParse::type_declaration*)IFC4_types[1056]); }
 void Ifc4::IfcTextFontName::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4::IfcTextFontName::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextTransformation
 const IfcParse::type_declaration& Ifc4::IfcTextTransformation::Class() { return *((IfcParse::type_declaration*)IFC4_types[1065]); }
 void Ifc4::IfcTextTransformation::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4::IfcTextTransformation::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalAdmittanceMeasure
 const IfcParse::type_declaration& Ifc4::IfcThermalAdmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1071]); }
 void Ifc4::IfcThermalAdmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcThermalAdmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalConductivityMeasure
 const IfcParse::type_declaration& Ifc4::IfcThermalConductivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1072]); }
 void Ifc4::IfcThermalConductivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcThermalConductivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalExpansionCoefficientMeasure
 const IfcParse::type_declaration& Ifc4::IfcThermalExpansionCoefficientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1073]); }
 void Ifc4::IfcThermalExpansionCoefficientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcThermalExpansionCoefficientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalResistanceMeasure
 const IfcParse::type_declaration& Ifc4::IfcThermalResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1074]); }
 void Ifc4::IfcThermalResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcThermalResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalTransmittanceMeasure
 const IfcParse::type_declaration& Ifc4::IfcThermalTransmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1075]); }
 void Ifc4::IfcThermalTransmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcThermalTransmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermodynamicTemperatureMeasure
 const IfcParse::type_declaration& Ifc4::IfcThermodynamicTemperatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1076]); }
 void Ifc4::IfcThermodynamicTemperatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcThermodynamicTemperatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTime
 const IfcParse::type_declaration& Ifc4::IfcTime::Class() { return *((IfcParse::type_declaration*)IFC4_types[1077]); }
 void Ifc4::IfcTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4::IfcTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeMeasure
 const IfcParse::type_declaration& Ifc4::IfcTimeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1078]); }
 void Ifc4::IfcTimeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcTimeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeStamp
 const IfcParse::type_declaration& Ifc4::IfcTimeStamp::Class() { return *((IfcParse::type_declaration*)IFC4_types[1084]); }
 void Ifc4::IfcTimeStamp::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4::IfcTimeStamp::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTorqueMeasure
 const IfcParse::type_declaration& Ifc4::IfcTorqueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1088]); }
 void Ifc4::IfcTorqueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcTorqueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcURIReference
 const IfcParse::type_declaration& Ifc4::IfcURIReference::Class() { return *((IfcParse::type_declaration*)IFC4_types[1119]); }
 void Ifc4::IfcURIReference::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4::IfcURIReference::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVaporPermeabilityMeasure
 const IfcParse::type_declaration& Ifc4::IfcVaporPermeabilityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1125]); }
 void Ifc4::IfcVaporPermeabilityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcVaporPermeabilityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumeMeasure
 const IfcParse::type_declaration& Ifc4::IfcVolumeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1138]); }
 void Ifc4::IfcVolumeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcVolumeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumetricFlowRateMeasure
 const IfcParse::type_declaration& Ifc4::IfcVolumetricFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1139]); }
 void Ifc4::IfcVolumetricFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcVolumetricFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingConstantMeasure
 const IfcParse::type_declaration& Ifc4::IfcWarpingConstantMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1145]); }
 void Ifc4::IfcWarpingConstantMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcWarpingConstantMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingMomentMeasure
 const IfcParse::type_declaration& Ifc4::IfcWarpingMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4_types[1146]); }
 void Ifc4::IfcWarpingMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4::IfcWarpingMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 
 // Function implementations for IfcActionRequest
@@ -7082,8 +7212,8 @@ int Ifc4::IfcBSplineSurface::UDegree() const {  int v = get_attribute_value(0);
 void Ifc4::IfcBSplineSurface::setUDegree(const int& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
 int Ifc4::IfcBSplineSurface::VDegree() const {  int v = get_attribute_value(1); return v; }
 void Ifc4::IfcBSplineSurface::setVDegree(const int& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
-std::vector< std::vector< ::Ifc4::IfcCartesianPoint > > Ifc4::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector_vector<::Ifc4::IfcCartesianPoint>(es); }
-void Ifc4::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
+std::vector< std::vector< ::Ifc4::IfcCartesianPoint > > Ifc4::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector<::Ifc4::IfcCartesianPoint>(es); }
+void Ifc4::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
 ::Ifc4::IfcBSplineSurfaceForm::Value Ifc4::IfcBSplineSurface::SurfaceForm() const {  return ::Ifc4::IfcBSplineSurfaceForm::FromString(get_attribute_value(3)); }
 void Ifc4::IfcBSplineSurface::setSurfaceForm(const ::Ifc4::IfcBSplineSurfaceForm::Value& v) { set_attribute_value(3, EnumerationReference(&::Ifc4::IfcBSplineSurfaceForm::Class(), (size_t) v));if constexpr (false)unset_attribute_value(3); }
 boost::logic::tribool Ifc4::IfcBSplineSurface::UClosed() const {  boost::logic::tribool v = get_attribute_value(4); return v; }
diff --git a/src/ifcparse/Ifc4x1.cpp b/src/ifcparse/Ifc4x1.cpp
index 453c6e6c00..7e8a702346 100644
--- a/src/ifcparse/Ifc4x1.cpp
+++ b/src/ifcparse/Ifc4x1.cpp
@@ -6253,522 +6253,652 @@ const IfcParse::select_type& Ifc4x1::IfcWarpingStiffnessSelect::Class() { return
 // Function implementations for IfcAbsorbedDoseMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcAbsorbedDoseMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[0]); }
 void Ifc4x1::IfcAbsorbedDoseMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcAbsorbedDoseMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAccelerationMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcAccelerationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1]); }
 void Ifc4x1::IfcAccelerationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcAccelerationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAmountOfSubstanceMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcAmountOfSubstanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[40]); }
 void Ifc4x1::IfcAmountOfSubstanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcAmountOfSubstanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAngularVelocityMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcAngularVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[43]); }
 void Ifc4x1::IfcAngularVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcAngularVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcArcIndex
 const IfcParse::type_declaration& Ifc4x1::IfcArcIndex::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[54]); }
 void Ifc4x1::IfcArcIndex::initialize(std::vector< int > /*[3:3]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcArcIndex::operator std::vector< int > /*[3:3]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaDensityMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcAreaDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[55]); }
 void Ifc4x1::IfcAreaDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcAreaDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcAreaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[56]); }
 void Ifc4x1::IfcAreaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcAreaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBinary
 const IfcParse::type_declaration& Ifc4x1::IfcBinary::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[74]); }
 void Ifc4x1::IfcBinary::initialize(boost::dynamic_bitset<> v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcBinary::operator boost::dynamic_bitset<>() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoolean
 const IfcParse::type_declaration& Ifc4x1::IfcBoolean::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[80]); }
 void Ifc4x1::IfcBoolean::initialize(bool v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcBoolean::operator bool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoxAlignment
 const IfcParse::type_declaration& Ifc4x1::IfcBoxAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[94]); }
+void Ifc4x1::IfcBoxAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x1::IfcBoxAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCardinalPointReference
 const IfcParse::type_declaration& Ifc4x1::IfcCardinalPointReference::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[129]); }
 void Ifc4x1::IfcCardinalPointReference::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcCardinalPointReference::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcComplexNumber
 const IfcParse::type_declaration& Ifc4x1::IfcComplexNumber::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[173]); }
 void Ifc4x1::IfcComplexNumber::initialize(std::vector< double > /*[1:2]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcComplexNumber::operator std::vector< double > /*[1:2]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCompoundPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcCompoundPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[181]); }
 void Ifc4x1::IfcCompoundPlaneAngleMeasure::initialize(std::vector< int > /*[3:4]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcCompoundPlaneAngleMeasure::operator std::vector< int > /*[3:4]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcContextDependentMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcContextDependentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[211]); }
 void Ifc4x1::IfcContextDependentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcContextDependentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCountMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcCountMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[233]); }
 void Ifc4x1::IfcCountMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcCountMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCurvatureMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcCurvatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[248]); }
 void Ifc4x1::IfcCurvatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcCurvatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDate
 const IfcParse::type_declaration& Ifc4x1::IfcDate::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[267]); }
 void Ifc4x1::IfcDate::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcDate::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDateTime
 const IfcParse::type_declaration& Ifc4x1::IfcDateTime::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[268]); }
 void Ifc4x1::IfcDateTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcDateTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInMonthNumber
 const IfcParse::type_declaration& Ifc4x1::IfcDayInMonthNumber::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[269]); }
 void Ifc4x1::IfcDayInMonthNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcDayInMonthNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInWeekNumber
 const IfcParse::type_declaration& Ifc4x1::IfcDayInWeekNumber::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[270]); }
 void Ifc4x1::IfcDayInWeekNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcDayInWeekNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDescriptiveMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcDescriptiveMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[277]); }
 void Ifc4x1::IfcDescriptiveMeasure::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcDescriptiveMeasure::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDimensionCount
 const IfcParse::type_declaration& Ifc4x1::IfcDimensionCount::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[279]); }
 void Ifc4x1::IfcDimensionCount::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcDimensionCount::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDoseEquivalentMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcDoseEquivalentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[318]); }
 void Ifc4x1::IfcDoseEquivalentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcDoseEquivalentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDuration
 const IfcParse::type_declaration& Ifc4x1::IfcDuration::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[330]); }
 void Ifc4x1::IfcDuration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcDuration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDynamicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcDynamicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[331]); }
 void Ifc4x1::IfcDynamicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcDynamicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCapacitanceMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcElectricCapacitanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[338]); }
 void Ifc4x1::IfcElectricCapacitanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcElectricCapacitanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricChargeMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcElectricChargeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[339]); }
 void Ifc4x1::IfcElectricChargeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcElectricChargeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricConductanceMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcElectricConductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[340]); }
 void Ifc4x1::IfcElectricConductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcElectricConductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCurrentMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcElectricCurrentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[341]); }
 void Ifc4x1::IfcElectricCurrentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcElectricCurrentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricResistanceMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcElectricResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[354]); }
 void Ifc4x1::IfcElectricResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcElectricResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricVoltageMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcElectricVoltageMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[358]); }
 void Ifc4x1::IfcElectricVoltageMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcElectricVoltageMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcEnergyMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcEnergyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[373]); }
 void Ifc4x1::IfcEnergyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcEnergyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontStyle
 const IfcParse::type_declaration& Ifc4x1::IfcFontStyle::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[449]); }
 void Ifc4x1::IfcFontStyle::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcFontStyle::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontVariant
 const IfcParse::type_declaration& Ifc4x1::IfcFontVariant::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[450]); }
 void Ifc4x1::IfcFontVariant::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcFontVariant::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontWeight
 const IfcParse::type_declaration& Ifc4x1::IfcFontWeight::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[451]); }
 void Ifc4x1::IfcFontWeight::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcFontWeight::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcForceMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[455]); }
 void Ifc4x1::IfcForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[456]); }
 void Ifc4x1::IfcFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcGloballyUniqueId
 const IfcParse::type_declaration& Ifc4x1::IfcGloballyUniqueId::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[472]); }
 void Ifc4x1::IfcGloballyUniqueId::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcGloballyUniqueId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcHeatFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[485]); }
 void Ifc4x1::IfcHeatFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcHeatFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatingValueMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcHeatingValueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[486]); }
 void Ifc4x1::IfcHeatingValueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcHeatingValueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIdentifier
 const IfcParse::type_declaration& Ifc4x1::IfcIdentifier::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[490]); }
 void Ifc4x1::IfcIdentifier::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcIdentifier::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIlluminanceMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcIlluminanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[491]); }
 void Ifc4x1::IfcIlluminanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcIlluminanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInductanceMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcInductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[499]); }
 void Ifc4x1::IfcInductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcInductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInteger
 const IfcParse::type_declaration& Ifc4x1::IfcInteger::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[500]); }
 void Ifc4x1::IfcInteger::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIntegerCountRateMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcIntegerCountRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[501]); }
 void Ifc4x1::IfcIntegerCountRateMeasure::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcIntegerCountRateMeasure::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIonConcentrationMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcIonConcentrationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[509]); }
 void Ifc4x1::IfcIonConcentrationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcIonConcentrationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIsothermalMoistureCapacityMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcIsothermalMoistureCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[513]); }
 void Ifc4x1::IfcIsothermalMoistureCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcIsothermalMoistureCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcKinematicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcKinematicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[517]); }
 void Ifc4x1::IfcKinematicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcKinematicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLabel
 const IfcParse::type_declaration& Ifc4x1::IfcLabel::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[519]); }
 void Ifc4x1::IfcLabel::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcLabel::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLanguageId
 const IfcParse::type_declaration& Ifc4x1::IfcLanguageId::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[527]); }
+void Ifc4x1::IfcLanguageId::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x1::IfcLanguageId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLengthMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[530]); }
 void Ifc4x1::IfcLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLineIndex
 const IfcParse::type_declaration& Ifc4x1::IfcLineIndex::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[555]); }
 void Ifc4x1::IfcLineIndex::initialize(std::vector< int > /*[2:?]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcLineIndex::operator std::vector< int > /*[2:?]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearForceMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcLinearForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[549]); }
 void Ifc4x1::IfcLinearForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcLinearForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearMomentMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcLinearMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[550]); }
 void Ifc4x1::IfcLinearMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcLinearMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcLinearStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[553]); }
 void Ifc4x1::IfcLinearStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcLinearStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearVelocityMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcLinearVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[554]); }
 void Ifc4x1::IfcLinearVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcLinearVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLogical
 const IfcParse::type_declaration& Ifc4x1::IfcLogical::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[559]); }
 void Ifc4x1::IfcLogical::initialize(boost::logic::tribool v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcLogical::operator boost::logic::tribool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousFluxMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcLuminousFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[563]); }
 void Ifc4x1::IfcLuminousFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcLuminousFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityDistributionMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcLuminousIntensityDistributionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[564]); }
 void Ifc4x1::IfcLuminousIntensityDistributionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcLuminousIntensityDistributionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcLuminousIntensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[565]); }
 void Ifc4x1::IfcLuminousIntensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcLuminousIntensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcMagneticFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[566]); }
 void Ifc4x1::IfcMagneticFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcMagneticFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcMagneticFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[567]); }
 void Ifc4x1::IfcMagneticFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcMagneticFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassDensityMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcMassDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[571]); }
 void Ifc4x1::IfcMassDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcMassDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcMassFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[572]); }
 void Ifc4x1::IfcMassFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcMassFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[573]); }
 void Ifc4x1::IfcMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassPerLengthMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcMassPerLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[574]); }
 void Ifc4x1::IfcMassPerLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcMassPerLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfElasticityMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcModulusOfElasticityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[610]); }
 void Ifc4x1::IfcModulusOfElasticityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcModulusOfElasticityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfLinearSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcModulusOfLinearSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[611]); }
 void Ifc4x1::IfcModulusOfLinearSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcModulusOfLinearSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfRotationalSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcModulusOfRotationalSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[612]); }
 void Ifc4x1::IfcModulusOfRotationalSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcModulusOfRotationalSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcModulusOfSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[614]); }
 void Ifc4x1::IfcModulusOfSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcModulusOfSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMoistureDiffusivityMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcMoistureDiffusivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[617]); }
 void Ifc4x1::IfcMoistureDiffusivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcMoistureDiffusivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMolecularWeightMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcMolecularWeightMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[618]); }
 void Ifc4x1::IfcMolecularWeightMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcMolecularWeightMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMomentOfInertiaMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcMomentOfInertiaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[619]); }
 void Ifc4x1::IfcMomentOfInertiaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcMomentOfInertiaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonetaryMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcMonetaryMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[620]); }
 void Ifc4x1::IfcMonetaryMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcMonetaryMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonthInYearNumber
 const IfcParse::type_declaration& Ifc4x1::IfcMonthInYearNumber::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[622]); }
 void Ifc4x1::IfcMonthInYearNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcMonthInYearNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNonNegativeLengthMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcNonNegativeLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[627]); }
+void Ifc4x1::IfcNonNegativeLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x1::IfcNonNegativeLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNormalisedRatioMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcNormalisedRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[628]); }
+void Ifc4x1::IfcNormalisedRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x1::IfcNormalisedRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNumericMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcNumericMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[630]); }
 void Ifc4x1::IfcNumericMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcNumericMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPHMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcPHMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[669]); }
 void Ifc4x1::IfcPHMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcPHMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcParameterValue
 const IfcParse::type_declaration& Ifc4x1::IfcParameterValue::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[658]); }
 void Ifc4x1::IfcParameterValue::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcParameterValue::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlanarForceMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcPlanarForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[688]); }
 void Ifc4x1::IfcPlanarForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcPlanarForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[690]); }
 void Ifc4x1::IfcPlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcPlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveInteger
 const IfcParse::type_declaration& Ifc4x1::IfcPositiveInteger::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[705]); }
+void Ifc4x1::IfcPositiveInteger::initialize(int v) { set_attribute_value(0, (v)); }
 Ifc4x1::IfcPositiveInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveLengthMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcPositiveLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[706]); }
+void Ifc4x1::IfcPositiveLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x1::IfcPositiveLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositivePlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcPositivePlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[707]); }
+void Ifc4x1::IfcPositivePlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x1::IfcPositivePlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveRatioMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcPositiveRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[708]); }
+void Ifc4x1::IfcPositiveRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x1::IfcPositiveRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPowerMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[710]); }
 void Ifc4x1::IfcPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPresentableText
 const IfcParse::type_declaration& Ifc4x1::IfcPresentableText::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[718]); }
 void Ifc4x1::IfcPresentableText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcPresentableText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPressureMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[725]); }
 void Ifc4x1::IfcPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPropertySetDefinitionSet
 const IfcParse::type_declaration& Ifc4x1::IfcPropertySetDefinitionSet::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[759]); }
 void Ifc4x1::IfcPropertySetDefinitionSet::initialize(std::vector< ::Ifc4x1::IfcPropertySetDefinition > v) { set_attribute_value(0, cast_vector<express::Base>(v)); }
+Ifc4x1::IfcPropertySetDefinitionSet::operator std::vector< ::Ifc4x1::IfcPropertySetDefinition >() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4x1::IfcPropertySetDefinition>(es); }
 
 // Function implementations for IfcRadioActivityMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcRadioActivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[783]); }
 void Ifc4x1::IfcRadioActivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcRadioActivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRatioMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[793]); }
 void Ifc4x1::IfcRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcReal
 const IfcParse::type_declaration& Ifc4x1::IfcReal::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[796]); }
 void Ifc4x1::IfcReal::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcReal::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcRotationalFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[889]); }
 void Ifc4x1::IfcRotationalFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcRotationalFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalMassMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcRotationalMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[890]); }
 void Ifc4x1::IfcRotationalMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcRotationalMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcRotationalStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[891]); }
 void Ifc4x1::IfcRotationalStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcRotationalStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionModulusMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcSectionModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[903]); }
 void Ifc4x1::IfcSectionModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcSectionModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionalAreaIntegralMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcSectionalAreaIntegralMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[899]); }
 void Ifc4x1::IfcSectionalAreaIntegralMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcSectionalAreaIntegralMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcShearModulusMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcShearModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[918]); }
 void Ifc4x1::IfcShearModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcShearModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSolidAngleMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcSolidAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[939]); }
 void Ifc4x1::IfcSolidAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcSolidAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerLevelMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcSoundPowerLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[942]); }
 void Ifc4x1::IfcSoundPowerLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcSoundPowerLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcSoundPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[943]); }
 void Ifc4x1::IfcSoundPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcSoundPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureLevelMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcSoundPressureLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[944]); }
 void Ifc4x1::IfcSoundPressureLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcSoundPressureLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcSoundPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[945]); }
 void Ifc4x1::IfcSoundPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcSoundPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecificHeatCapacityMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcSpecificHeatCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[960]); }
 void Ifc4x1::IfcSpecificHeatCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcSpecificHeatCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularExponent
 const IfcParse::type_declaration& Ifc4x1::IfcSpecularExponent::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[961]); }
 void Ifc4x1::IfcSpecularExponent::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcSpecularExponent::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularRoughness
 const IfcParse::type_declaration& Ifc4x1::IfcSpecularRoughness::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[963]); }
 void Ifc4x1::IfcSpecularRoughness::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcSpecularRoughness::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureGradientMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcTemperatureGradientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1068]); }
 void Ifc4x1::IfcTemperatureGradientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcTemperatureGradientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureRateOfChangeMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcTemperatureRateOfChangeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1069]); }
 void Ifc4x1::IfcTemperatureRateOfChangeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcTemperatureRateOfChangeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcText
 const IfcParse::type_declaration& Ifc4x1::IfcText::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1078]); }
 void Ifc4x1::IfcText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextAlignment
 const IfcParse::type_declaration& Ifc4x1::IfcTextAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1079]); }
 void Ifc4x1::IfcTextAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcTextAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextDecoration
 const IfcParse::type_declaration& Ifc4x1::IfcTextDecoration::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1080]); }
 void Ifc4x1::IfcTextDecoration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcTextDecoration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextFontName
 const IfcParse::type_declaration& Ifc4x1::IfcTextFontName::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1081]); }
 void Ifc4x1::IfcTextFontName::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcTextFontName::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextTransformation
 const IfcParse::type_declaration& Ifc4x1::IfcTextTransformation::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1090]); }
 void Ifc4x1::IfcTextTransformation::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcTextTransformation::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalAdmittanceMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcThermalAdmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1096]); }
 void Ifc4x1::IfcThermalAdmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcThermalAdmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalConductivityMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcThermalConductivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1097]); }
 void Ifc4x1::IfcThermalConductivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcThermalConductivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalExpansionCoefficientMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcThermalExpansionCoefficientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1098]); }
 void Ifc4x1::IfcThermalExpansionCoefficientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcThermalExpansionCoefficientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalResistanceMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcThermalResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1099]); }
 void Ifc4x1::IfcThermalResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcThermalResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalTransmittanceMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcThermalTransmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1100]); }
 void Ifc4x1::IfcThermalTransmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcThermalTransmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermodynamicTemperatureMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcThermodynamicTemperatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1101]); }
 void Ifc4x1::IfcThermodynamicTemperatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcThermodynamicTemperatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTime
 const IfcParse::type_declaration& Ifc4x1::IfcTime::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1102]); }
 void Ifc4x1::IfcTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcTimeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1103]); }
 void Ifc4x1::IfcTimeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcTimeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeStamp
 const IfcParse::type_declaration& Ifc4x1::IfcTimeStamp::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1109]); }
 void Ifc4x1::IfcTimeStamp::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcTimeStamp::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTorqueMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcTorqueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1113]); }
 void Ifc4x1::IfcTorqueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcTorqueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcURIReference
 const IfcParse::type_declaration& Ifc4x1::IfcURIReference::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1147]); }
 void Ifc4x1::IfcURIReference::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcURIReference::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVaporPermeabilityMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcVaporPermeabilityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1153]); }
 void Ifc4x1::IfcVaporPermeabilityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcVaporPermeabilityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumeMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcVolumeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1166]); }
 void Ifc4x1::IfcVolumeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcVolumeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumetricFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcVolumetricFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1167]); }
 void Ifc4x1::IfcVolumetricFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcVolumetricFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingConstantMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcWarpingConstantMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1173]); }
 void Ifc4x1::IfcWarpingConstantMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcWarpingConstantMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingMomentMeasure
 const IfcParse::type_declaration& Ifc4x1::IfcWarpingMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X1_types[1174]); }
 void Ifc4x1::IfcWarpingMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x1::IfcWarpingMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 
 // Function implementations for IfcActionRequest
@@ -7271,8 +7401,8 @@ int Ifc4x1::IfcBSplineSurface::UDegree() const {  int v = get_attribute_value(0)
 void Ifc4x1::IfcBSplineSurface::setUDegree(const int& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
 int Ifc4x1::IfcBSplineSurface::VDegree() const {  int v = get_attribute_value(1); return v; }
 void Ifc4x1::IfcBSplineSurface::setVDegree(const int& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
-std::vector< std::vector< ::Ifc4x1::IfcCartesianPoint > > Ifc4x1::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector_vector<::Ifc4x1::IfcCartesianPoint>(es); }
-void Ifc4x1::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x1::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
+std::vector< std::vector< ::Ifc4x1::IfcCartesianPoint > > Ifc4x1::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector<::Ifc4x1::IfcCartesianPoint>(es); }
+void Ifc4x1::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x1::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
 ::Ifc4x1::IfcBSplineSurfaceForm::Value Ifc4x1::IfcBSplineSurface::SurfaceForm() const {  return ::Ifc4x1::IfcBSplineSurfaceForm::FromString(get_attribute_value(3)); }
 void Ifc4x1::IfcBSplineSurface::setSurfaceForm(const ::Ifc4x1::IfcBSplineSurfaceForm::Value& v) { set_attribute_value(3, EnumerationReference(&::Ifc4x1::IfcBSplineSurfaceForm::Class(), (size_t) v));if constexpr (false)unset_attribute_value(3); }
 boost::logic::tribool Ifc4x1::IfcBSplineSurface::UClosed() const {  boost::logic::tribool v = get_attribute_value(4); return v; }
diff --git a/src/ifcparse/Ifc4x2.cpp b/src/ifcparse/Ifc4x2.cpp
index f4ec422e43..f67b9887f0 100644
--- a/src/ifcparse/Ifc4x2.cpp
+++ b/src/ifcparse/Ifc4x2.cpp
@@ -6456,522 +6456,652 @@ const IfcParse::select_type& Ifc4x2::IfcWarpingStiffnessSelect::Class() { return
 // Function implementations for IfcAbsorbedDoseMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcAbsorbedDoseMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[0]); }
 void Ifc4x2::IfcAbsorbedDoseMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcAbsorbedDoseMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAccelerationMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcAccelerationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1]); }
 void Ifc4x2::IfcAccelerationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcAccelerationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAmountOfSubstanceMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcAmountOfSubstanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[40]); }
 void Ifc4x2::IfcAmountOfSubstanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcAmountOfSubstanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAngularVelocityMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcAngularVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[43]); }
 void Ifc4x2::IfcAngularVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcAngularVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcArcIndex
 const IfcParse::type_declaration& Ifc4x2::IfcArcIndex::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[54]); }
 void Ifc4x2::IfcArcIndex::initialize(std::vector< int > /*[3:3]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcArcIndex::operator std::vector< int > /*[3:3]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaDensityMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcAreaDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[55]); }
 void Ifc4x2::IfcAreaDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcAreaDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcAreaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[56]); }
 void Ifc4x2::IfcAreaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcAreaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBinary
 const IfcParse::type_declaration& Ifc4x2::IfcBinary::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[78]); }
 void Ifc4x2::IfcBinary::initialize(boost::dynamic_bitset<> v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcBinary::operator boost::dynamic_bitset<>() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoolean
 const IfcParse::type_declaration& Ifc4x2::IfcBoolean::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[84]); }
 void Ifc4x2::IfcBoolean::initialize(bool v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcBoolean::operator bool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoxAlignment
 const IfcParse::type_declaration& Ifc4x2::IfcBoxAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[98]); }
+void Ifc4x2::IfcBoxAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x2::IfcBoxAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCardinalPointReference
 const IfcParse::type_declaration& Ifc4x2::IfcCardinalPointReference::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[140]); }
 void Ifc4x2::IfcCardinalPointReference::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcCardinalPointReference::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcComplexNumber
 const IfcParse::type_declaration& Ifc4x2::IfcComplexNumber::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[184]); }
 void Ifc4x2::IfcComplexNumber::initialize(std::vector< double > /*[1:2]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcComplexNumber::operator std::vector< double > /*[1:2]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCompoundPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcCompoundPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[192]); }
 void Ifc4x2::IfcCompoundPlaneAngleMeasure::initialize(std::vector< int > /*[3:4]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcCompoundPlaneAngleMeasure::operator std::vector< int > /*[3:4]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcContextDependentMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcContextDependentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[222]); }
 void Ifc4x2::IfcContextDependentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcContextDependentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCountMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcCountMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[244]); }
 void Ifc4x2::IfcCountMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcCountMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCurvatureMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcCurvatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[259]); }
 void Ifc4x2::IfcCurvatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcCurvatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDate
 const IfcParse::type_declaration& Ifc4x2::IfcDate::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[278]); }
 void Ifc4x2::IfcDate::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcDate::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDateTime
 const IfcParse::type_declaration& Ifc4x2::IfcDateTime::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[279]); }
 void Ifc4x2::IfcDateTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcDateTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInMonthNumber
 const IfcParse::type_declaration& Ifc4x2::IfcDayInMonthNumber::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[280]); }
 void Ifc4x2::IfcDayInMonthNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcDayInMonthNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInWeekNumber
 const IfcParse::type_declaration& Ifc4x2::IfcDayInWeekNumber::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[281]); }
 void Ifc4x2::IfcDayInWeekNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcDayInWeekNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDescriptiveMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcDescriptiveMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[290]); }
 void Ifc4x2::IfcDescriptiveMeasure::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcDescriptiveMeasure::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDimensionCount
 const IfcParse::type_declaration& Ifc4x2::IfcDimensionCount::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[292]); }
 void Ifc4x2::IfcDimensionCount::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcDimensionCount::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDoseEquivalentMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcDoseEquivalentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[331]); }
 void Ifc4x2::IfcDoseEquivalentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcDoseEquivalentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDuration
 const IfcParse::type_declaration& Ifc4x2::IfcDuration::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[343]); }
 void Ifc4x2::IfcDuration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcDuration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDynamicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcDynamicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[344]); }
 void Ifc4x2::IfcDynamicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcDynamicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCapacitanceMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcElectricCapacitanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[351]); }
 void Ifc4x2::IfcElectricCapacitanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcElectricCapacitanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricChargeMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcElectricChargeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[352]); }
 void Ifc4x2::IfcElectricChargeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcElectricChargeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricConductanceMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcElectricConductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[353]); }
 void Ifc4x2::IfcElectricConductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcElectricConductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCurrentMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcElectricCurrentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[354]); }
 void Ifc4x2::IfcElectricCurrentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcElectricCurrentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricResistanceMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcElectricResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[367]); }
 void Ifc4x2::IfcElectricResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcElectricResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricVoltageMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcElectricVoltageMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[371]); }
 void Ifc4x2::IfcElectricVoltageMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcElectricVoltageMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcEnergyMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcEnergyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[386]); }
 void Ifc4x2::IfcEnergyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcEnergyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontStyle
 const IfcParse::type_declaration& Ifc4x2::IfcFontStyle::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[464]); }
 void Ifc4x2::IfcFontStyle::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcFontStyle::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontVariant
 const IfcParse::type_declaration& Ifc4x2::IfcFontVariant::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[465]); }
 void Ifc4x2::IfcFontVariant::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcFontVariant::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontWeight
 const IfcParse::type_declaration& Ifc4x2::IfcFontWeight::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[466]); }
 void Ifc4x2::IfcFontWeight::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcFontWeight::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcForceMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[470]); }
 void Ifc4x2::IfcForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[471]); }
 void Ifc4x2::IfcFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcGloballyUniqueId
 const IfcParse::type_declaration& Ifc4x2::IfcGloballyUniqueId::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[487]); }
 void Ifc4x2::IfcGloballyUniqueId::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcGloballyUniqueId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcHeatFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[500]); }
 void Ifc4x2::IfcHeatFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcHeatFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatingValueMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcHeatingValueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[501]); }
 void Ifc4x2::IfcHeatingValueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcHeatingValueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIdentifier
 const IfcParse::type_declaration& Ifc4x2::IfcIdentifier::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[505]); }
 void Ifc4x2::IfcIdentifier::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcIdentifier::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIlluminanceMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcIlluminanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[506]); }
 void Ifc4x2::IfcIlluminanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcIlluminanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInductanceMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcInductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[514]); }
 void Ifc4x2::IfcInductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcInductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInteger
 const IfcParse::type_declaration& Ifc4x2::IfcInteger::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[515]); }
 void Ifc4x2::IfcInteger::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIntegerCountRateMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcIntegerCountRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[516]); }
 void Ifc4x2::IfcIntegerCountRateMeasure::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcIntegerCountRateMeasure::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIonConcentrationMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcIonConcentrationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[524]); }
 void Ifc4x2::IfcIonConcentrationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcIonConcentrationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIsothermalMoistureCapacityMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcIsothermalMoistureCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[528]); }
 void Ifc4x2::IfcIsothermalMoistureCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcIsothermalMoistureCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcKinematicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcKinematicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[532]); }
 void Ifc4x2::IfcKinematicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcKinematicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLabel
 const IfcParse::type_declaration& Ifc4x2::IfcLabel::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[534]); }
 void Ifc4x2::IfcLabel::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcLabel::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLanguageId
 const IfcParse::type_declaration& Ifc4x2::IfcLanguageId::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[542]); }
+void Ifc4x2::IfcLanguageId::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x2::IfcLanguageId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLengthMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[545]); }
 void Ifc4x2::IfcLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLineIndex
 const IfcParse::type_declaration& Ifc4x2::IfcLineIndex::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[570]); }
 void Ifc4x2::IfcLineIndex::initialize(std::vector< int > /*[2:?]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcLineIndex::operator std::vector< int > /*[2:?]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearForceMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcLinearForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[564]); }
 void Ifc4x2::IfcLinearForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcLinearForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearMomentMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcLinearMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[565]); }
 void Ifc4x2::IfcLinearMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcLinearMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcLinearStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[568]); }
 void Ifc4x2::IfcLinearStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcLinearStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearVelocityMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcLinearVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[569]); }
 void Ifc4x2::IfcLinearVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcLinearVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLogical
 const IfcParse::type_declaration& Ifc4x2::IfcLogical::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[574]); }
 void Ifc4x2::IfcLogical::initialize(boost::logic::tribool v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcLogical::operator boost::logic::tribool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousFluxMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcLuminousFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[578]); }
 void Ifc4x2::IfcLuminousFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcLuminousFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityDistributionMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcLuminousIntensityDistributionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[579]); }
 void Ifc4x2::IfcLuminousIntensityDistributionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcLuminousIntensityDistributionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcLuminousIntensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[580]); }
 void Ifc4x2::IfcLuminousIntensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcLuminousIntensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcMagneticFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[581]); }
 void Ifc4x2::IfcMagneticFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcMagneticFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcMagneticFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[582]); }
 void Ifc4x2::IfcMagneticFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcMagneticFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassDensityMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcMassDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[586]); }
 void Ifc4x2::IfcMassDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcMassDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcMassFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[587]); }
 void Ifc4x2::IfcMassFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcMassFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[588]); }
 void Ifc4x2::IfcMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassPerLengthMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcMassPerLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[589]); }
 void Ifc4x2::IfcMassPerLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcMassPerLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfElasticityMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcModulusOfElasticityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[625]); }
 void Ifc4x2::IfcModulusOfElasticityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcModulusOfElasticityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfLinearSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcModulusOfLinearSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[626]); }
 void Ifc4x2::IfcModulusOfLinearSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcModulusOfLinearSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfRotationalSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcModulusOfRotationalSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[627]); }
 void Ifc4x2::IfcModulusOfRotationalSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcModulusOfRotationalSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcModulusOfSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[629]); }
 void Ifc4x2::IfcModulusOfSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcModulusOfSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMoistureDiffusivityMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcMoistureDiffusivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[632]); }
 void Ifc4x2::IfcMoistureDiffusivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcMoistureDiffusivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMolecularWeightMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcMolecularWeightMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[633]); }
 void Ifc4x2::IfcMolecularWeightMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcMolecularWeightMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMomentOfInertiaMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcMomentOfInertiaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[634]); }
 void Ifc4x2::IfcMomentOfInertiaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcMomentOfInertiaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonetaryMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcMonetaryMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[635]); }
 void Ifc4x2::IfcMonetaryMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcMonetaryMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonthInYearNumber
 const IfcParse::type_declaration& Ifc4x2::IfcMonthInYearNumber::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[637]); }
 void Ifc4x2::IfcMonthInYearNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcMonthInYearNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNonNegativeLengthMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcNonNegativeLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[642]); }
+void Ifc4x2::IfcNonNegativeLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x2::IfcNonNegativeLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNormalisedRatioMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcNormalisedRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[643]); }
+void Ifc4x2::IfcNormalisedRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x2::IfcNormalisedRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNumericMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcNumericMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[645]); }
 void Ifc4x2::IfcNumericMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcNumericMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPHMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcPHMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[684]); }
 void Ifc4x2::IfcPHMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcPHMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcParameterValue
 const IfcParse::type_declaration& Ifc4x2::IfcParameterValue::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[673]); }
 void Ifc4x2::IfcParameterValue::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcParameterValue::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlanarForceMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcPlanarForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[703]); }
 void Ifc4x2::IfcPlanarForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcPlanarForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[705]); }
 void Ifc4x2::IfcPlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcPlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveInteger
 const IfcParse::type_declaration& Ifc4x2::IfcPositiveInteger::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[720]); }
+void Ifc4x2::IfcPositiveInteger::initialize(int v) { set_attribute_value(0, (v)); }
 Ifc4x2::IfcPositiveInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveLengthMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcPositiveLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[721]); }
+void Ifc4x2::IfcPositiveLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x2::IfcPositiveLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositivePlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcPositivePlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[722]); }
+void Ifc4x2::IfcPositivePlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x2::IfcPositivePlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveRatioMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcPositiveRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[723]); }
+void Ifc4x2::IfcPositiveRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x2::IfcPositiveRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPowerMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[725]); }
 void Ifc4x2::IfcPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPresentableText
 const IfcParse::type_declaration& Ifc4x2::IfcPresentableText::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[733]); }
 void Ifc4x2::IfcPresentableText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcPresentableText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPressureMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[740]); }
 void Ifc4x2::IfcPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPropertySetDefinitionSet
 const IfcParse::type_declaration& Ifc4x2::IfcPropertySetDefinitionSet::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[774]); }
 void Ifc4x2::IfcPropertySetDefinitionSet::initialize(std::vector< ::Ifc4x2::IfcPropertySetDefinition > v) { set_attribute_value(0, cast_vector<express::Base>(v)); }
+Ifc4x2::IfcPropertySetDefinitionSet::operator std::vector< ::Ifc4x2::IfcPropertySetDefinition >() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4x2::IfcPropertySetDefinition>(es); }
 
 // Function implementations for IfcRadioActivityMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcRadioActivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[798]); }
 void Ifc4x2::IfcRadioActivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcRadioActivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRatioMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[808]); }
 void Ifc4x2::IfcRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcReal
 const IfcParse::type_declaration& Ifc4x2::IfcReal::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[811]); }
 void Ifc4x2::IfcReal::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcReal::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcRotationalFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[905]); }
 void Ifc4x2::IfcRotationalFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcRotationalFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalMassMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcRotationalMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[906]); }
 void Ifc4x2::IfcRotationalMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcRotationalMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcRotationalStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[907]); }
 void Ifc4x2::IfcRotationalStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcRotationalStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionModulusMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcSectionModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[919]); }
 void Ifc4x2::IfcSectionModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcSectionModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionalAreaIntegralMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcSectionalAreaIntegralMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[915]); }
 void Ifc4x2::IfcSectionalAreaIntegralMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcSectionalAreaIntegralMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcShearModulusMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcShearModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[934]); }
 void Ifc4x2::IfcShearModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcShearModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSolidAngleMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcSolidAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[955]); }
 void Ifc4x2::IfcSolidAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcSolidAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerLevelMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcSoundPowerLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[958]); }
 void Ifc4x2::IfcSoundPowerLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcSoundPowerLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcSoundPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[959]); }
 void Ifc4x2::IfcSoundPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcSoundPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureLevelMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcSoundPressureLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[960]); }
 void Ifc4x2::IfcSoundPressureLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcSoundPressureLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcSoundPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[961]); }
 void Ifc4x2::IfcSoundPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcSoundPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecificHeatCapacityMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcSpecificHeatCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[976]); }
 void Ifc4x2::IfcSpecificHeatCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcSpecificHeatCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularExponent
 const IfcParse::type_declaration& Ifc4x2::IfcSpecularExponent::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[977]); }
 void Ifc4x2::IfcSpecularExponent::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcSpecularExponent::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularRoughness
 const IfcParse::type_declaration& Ifc4x2::IfcSpecularRoughness::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[979]); }
 void Ifc4x2::IfcSpecularRoughness::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcSpecularRoughness::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureGradientMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcTemperatureGradientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1084]); }
 void Ifc4x2::IfcTemperatureGradientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcTemperatureGradientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureRateOfChangeMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcTemperatureRateOfChangeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1085]); }
 void Ifc4x2::IfcTemperatureRateOfChangeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcTemperatureRateOfChangeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcText
 const IfcParse::type_declaration& Ifc4x2::IfcText::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1097]); }
 void Ifc4x2::IfcText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextAlignment
 const IfcParse::type_declaration& Ifc4x2::IfcTextAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1098]); }
 void Ifc4x2::IfcTextAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcTextAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextDecoration
 const IfcParse::type_declaration& Ifc4x2::IfcTextDecoration::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1099]); }
 void Ifc4x2::IfcTextDecoration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcTextDecoration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextFontName
 const IfcParse::type_declaration& Ifc4x2::IfcTextFontName::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1100]); }
 void Ifc4x2::IfcTextFontName::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcTextFontName::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextTransformation
 const IfcParse::type_declaration& Ifc4x2::IfcTextTransformation::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1109]); }
 void Ifc4x2::IfcTextTransformation::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcTextTransformation::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalAdmittanceMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcThermalAdmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1115]); }
 void Ifc4x2::IfcThermalAdmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcThermalAdmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalConductivityMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcThermalConductivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1116]); }
 void Ifc4x2::IfcThermalConductivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcThermalConductivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalExpansionCoefficientMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcThermalExpansionCoefficientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1117]); }
 void Ifc4x2::IfcThermalExpansionCoefficientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcThermalExpansionCoefficientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalResistanceMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcThermalResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1118]); }
 void Ifc4x2::IfcThermalResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcThermalResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalTransmittanceMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcThermalTransmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1119]); }
 void Ifc4x2::IfcThermalTransmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcThermalTransmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermodynamicTemperatureMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcThermodynamicTemperatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1120]); }
 void Ifc4x2::IfcThermodynamicTemperatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcThermodynamicTemperatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTime
 const IfcParse::type_declaration& Ifc4x2::IfcTime::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1121]); }
 void Ifc4x2::IfcTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcTimeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1122]); }
 void Ifc4x2::IfcTimeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcTimeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeStamp
 const IfcParse::type_declaration& Ifc4x2::IfcTimeStamp::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1128]); }
 void Ifc4x2::IfcTimeStamp::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcTimeStamp::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTorqueMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcTorqueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1132]); }
 void Ifc4x2::IfcTorqueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcTorqueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcURIReference
 const IfcParse::type_declaration& Ifc4x2::IfcURIReference::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1166]); }
 void Ifc4x2::IfcURIReference::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcURIReference::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVaporPermeabilityMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcVaporPermeabilityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1172]); }
 void Ifc4x2::IfcVaporPermeabilityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcVaporPermeabilityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumeMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcVolumeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1188]); }
 void Ifc4x2::IfcVolumeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcVolumeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumetricFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcVolumetricFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1189]); }
 void Ifc4x2::IfcVolumetricFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcVolumetricFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingConstantMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcWarpingConstantMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1195]); }
 void Ifc4x2::IfcWarpingConstantMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcWarpingConstantMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingMomentMeasure
 const IfcParse::type_declaration& Ifc4x2::IfcWarpingMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X2_types[1196]); }
 void Ifc4x2::IfcWarpingMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x2::IfcWarpingMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 
 // Function implementations for IfcActionRequest
@@ -7474,8 +7604,8 @@ int Ifc4x2::IfcBSplineSurface::UDegree() const {  int v = get_attribute_value(0)
 void Ifc4x2::IfcBSplineSurface::setUDegree(const int& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
 int Ifc4x2::IfcBSplineSurface::VDegree() const {  int v = get_attribute_value(1); return v; }
 void Ifc4x2::IfcBSplineSurface::setVDegree(const int& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
-std::vector< std::vector< ::Ifc4x2::IfcCartesianPoint > > Ifc4x2::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector_vector<::Ifc4x2::IfcCartesianPoint>(es); }
-void Ifc4x2::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x2::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
+std::vector< std::vector< ::Ifc4x2::IfcCartesianPoint > > Ifc4x2::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector<::Ifc4x2::IfcCartesianPoint>(es); }
+void Ifc4x2::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x2::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
 ::Ifc4x2::IfcBSplineSurfaceForm::Value Ifc4x2::IfcBSplineSurface::SurfaceForm() const {  return ::Ifc4x2::IfcBSplineSurfaceForm::FromString(get_attribute_value(3)); }
 void Ifc4x2::IfcBSplineSurface::setSurfaceForm(const ::Ifc4x2::IfcBSplineSurfaceForm::Value& v) { set_attribute_value(3, EnumerationReference(&::Ifc4x2::IfcBSplineSurfaceForm::Class(), (size_t) v));if constexpr (false)unset_attribute_value(3); }
 boost::logic::tribool Ifc4x2::IfcBSplineSurface::UClosed() const {  boost::logic::tribool v = get_attribute_value(4); return v; }
diff --git a/src/ifcparse/Ifc4x3.cpp b/src/ifcparse/Ifc4x3.cpp
index 1c22f80606..470eec5549 100644
--- a/src/ifcparse/Ifc4x3.cpp
+++ b/src/ifcparse/Ifc4x3.cpp
@@ -7357,522 +7357,652 @@ const IfcParse::select_type& Ifc4x3::IfcWarpingStiffnessSelect::Class() { return
 // Function implementations for IfcAbsorbedDoseMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcAbsorbedDoseMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[0]); }
 void Ifc4x3::IfcAbsorbedDoseMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcAbsorbedDoseMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAccelerationMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcAccelerationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1]); }
 void Ifc4x3::IfcAccelerationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcAccelerationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAmountOfSubstanceMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcAmountOfSubstanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[42]); }
 void Ifc4x3::IfcAmountOfSubstanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcAmountOfSubstanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAngularVelocityMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcAngularVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[45]); }
 void Ifc4x3::IfcAngularVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcAngularVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcArcIndex
 const IfcParse::type_declaration& Ifc4x3::IfcArcIndex::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[57]); }
 void Ifc4x3::IfcArcIndex::initialize(std::vector< int > /*[3:3]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcArcIndex::operator std::vector< int > /*[3:3]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaDensityMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcAreaDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[58]); }
 void Ifc4x3::IfcAreaDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcAreaDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcAreaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[59]); }
 void Ifc4x3::IfcAreaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcAreaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBinary
 const IfcParse::type_declaration& Ifc4x3::IfcBinary::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[81]); }
 void Ifc4x3::IfcBinary::initialize(boost::dynamic_bitset<> v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcBinary::operator boost::dynamic_bitset<>() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoolean
 const IfcParse::type_declaration& Ifc4x3::IfcBoolean::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[87]); }
 void Ifc4x3::IfcBoolean::initialize(bool v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcBoolean::operator bool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoxAlignment
 const IfcParse::type_declaration& Ifc4x3::IfcBoxAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[102]); }
+void Ifc4x3::IfcBoxAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x3::IfcBoxAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCardinalPointReference
 const IfcParse::type_declaration& Ifc4x3::IfcCardinalPointReference::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[146]); }
 void Ifc4x3::IfcCardinalPointReference::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcCardinalPointReference::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcComplexNumber
 const IfcParse::type_declaration& Ifc4x3::IfcComplexNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[189]); }
 void Ifc4x3::IfcComplexNumber::initialize(std::vector< double > /*[1:2]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcComplexNumber::operator std::vector< double > /*[1:2]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCompoundPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcCompoundPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[197]); }
 void Ifc4x3::IfcCompoundPlaneAngleMeasure::initialize(std::vector< int > /*[3:4]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcCompoundPlaneAngleMeasure::operator std::vector< int > /*[3:4]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcContextDependentMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcContextDependentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[227]); }
 void Ifc4x3::IfcContextDependentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcContextDependentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCountMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcCountMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[253]); }
 void Ifc4x3::IfcCountMeasure::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcCountMeasure::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCurvatureMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcCurvatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[271]); }
 void Ifc4x3::IfcCurvatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcCurvatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDate
 const IfcParse::type_declaration& Ifc4x3::IfcDate::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[291]); }
 void Ifc4x3::IfcDate::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcDate::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDateTime
 const IfcParse::type_declaration& Ifc4x3::IfcDateTime::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[292]); }
 void Ifc4x3::IfcDateTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcDateTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInMonthNumber
 const IfcParse::type_declaration& Ifc4x3::IfcDayInMonthNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[293]); }
 void Ifc4x3::IfcDayInMonthNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcDayInMonthNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInWeekNumber
 const IfcParse::type_declaration& Ifc4x3::IfcDayInWeekNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[294]); }
 void Ifc4x3::IfcDayInWeekNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcDayInWeekNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDescriptiveMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcDescriptiveMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[303]); }
 void Ifc4x3::IfcDescriptiveMeasure::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcDescriptiveMeasure::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDimensionCount
 const IfcParse::type_declaration& Ifc4x3::IfcDimensionCount::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[305]); }
 void Ifc4x3::IfcDimensionCount::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcDimensionCount::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDoseEquivalentMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcDoseEquivalentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[346]); }
 void Ifc4x3::IfcDoseEquivalentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcDoseEquivalentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDuration
 const IfcParse::type_declaration& Ifc4x3::IfcDuration::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[358]); }
 void Ifc4x3::IfcDuration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcDuration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDynamicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcDynamicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[359]); }
 void Ifc4x3::IfcDynamicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcDynamicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCapacitanceMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcElectricCapacitanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[371]); }
 void Ifc4x3::IfcElectricCapacitanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcElectricCapacitanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricChargeMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcElectricChargeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[372]); }
 void Ifc4x3::IfcElectricChargeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcElectricChargeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricConductanceMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcElectricConductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[373]); }
 void Ifc4x3::IfcElectricConductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcElectricConductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCurrentMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcElectricCurrentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[374]); }
 void Ifc4x3::IfcElectricCurrentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcElectricCurrentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricResistanceMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcElectricResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[390]); }
 void Ifc4x3::IfcElectricResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcElectricResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricVoltageMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcElectricVoltageMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[394]); }
 void Ifc4x3::IfcElectricVoltageMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcElectricVoltageMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcEnergyMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcEnergyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[409]); }
 void Ifc4x3::IfcEnergyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcEnergyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontStyle
 const IfcParse::type_declaration& Ifc4x3::IfcFontStyle::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[490]); }
 void Ifc4x3::IfcFontStyle::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcFontStyle::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontVariant
 const IfcParse::type_declaration& Ifc4x3::IfcFontVariant::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[491]); }
 void Ifc4x3::IfcFontVariant::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcFontVariant::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontWeight
 const IfcParse::type_declaration& Ifc4x3::IfcFontWeight::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[492]); }
 void Ifc4x3::IfcFontWeight::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcFontWeight::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcForceMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[496]); }
 void Ifc4x3::IfcForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[497]); }
 void Ifc4x3::IfcFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcGloballyUniqueId
 const IfcParse::type_declaration& Ifc4x3::IfcGloballyUniqueId::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[519]); }
 void Ifc4x3::IfcGloballyUniqueId::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcGloballyUniqueId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcHeatFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[533]); }
 void Ifc4x3::IfcHeatFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcHeatFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatingValueMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcHeatingValueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[534]); }
 void Ifc4x3::IfcHeatingValueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcHeatingValueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIdentifier
 const IfcParse::type_declaration& Ifc4x3::IfcIdentifier::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[538]); }
 void Ifc4x3::IfcIdentifier::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcIdentifier::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIlluminanceMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcIlluminanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[539]); }
 void Ifc4x3::IfcIlluminanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcIlluminanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInductanceMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcInductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[551]); }
 void Ifc4x3::IfcInductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcInductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInteger
 const IfcParse::type_declaration& Ifc4x3::IfcInteger::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[552]); }
 void Ifc4x3::IfcInteger::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIntegerCountRateMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcIntegerCountRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[553]); }
 void Ifc4x3::IfcIntegerCountRateMeasure::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcIntegerCountRateMeasure::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIonConcentrationMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcIonConcentrationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[562]); }
 void Ifc4x3::IfcIonConcentrationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcIonConcentrationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIsothermalMoistureCapacityMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcIsothermalMoistureCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[566]); }
 void Ifc4x3::IfcIsothermalMoistureCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcIsothermalMoistureCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcKinematicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcKinematicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[572]); }
 void Ifc4x3::IfcKinematicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcKinematicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLabel
 const IfcParse::type_declaration& Ifc4x3::IfcLabel::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[574]); }
 void Ifc4x3::IfcLabel::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcLabel::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLanguageId
 const IfcParse::type_declaration& Ifc4x3::IfcLanguageId::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[582]); }
+void Ifc4x3::IfcLanguageId::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x3::IfcLanguageId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLengthMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[585]); }
 void Ifc4x3::IfcLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLineIndex
 const IfcParse::type_declaration& Ifc4x3::IfcLineIndex::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[611]); }
 void Ifc4x3::IfcLineIndex::initialize(std::vector< int > /*[2:?]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcLineIndex::operator std::vector< int > /*[2:?]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearForceMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcLinearForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[605]); }
 void Ifc4x3::IfcLinearForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcLinearForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearMomentMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcLinearMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[606]); }
 void Ifc4x3::IfcLinearMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcLinearMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcLinearStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[609]); }
 void Ifc4x3::IfcLinearStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcLinearStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearVelocityMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcLinearVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[610]); }
 void Ifc4x3::IfcLinearVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcLinearVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLogical
 const IfcParse::type_declaration& Ifc4x3::IfcLogical::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[617]); }
 void Ifc4x3::IfcLogical::initialize(boost::logic::tribool v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcLogical::operator boost::logic::tribool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousFluxMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcLuminousFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[621]); }
 void Ifc4x3::IfcLuminousFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcLuminousFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityDistributionMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcLuminousIntensityDistributionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[622]); }
 void Ifc4x3::IfcLuminousIntensityDistributionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcLuminousIntensityDistributionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcLuminousIntensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[623]); }
 void Ifc4x3::IfcLuminousIntensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcLuminousIntensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcMagneticFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[624]); }
 void Ifc4x3::IfcMagneticFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcMagneticFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcMagneticFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[625]); }
 void Ifc4x3::IfcMagneticFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcMagneticFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassDensityMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcMassDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[633]); }
 void Ifc4x3::IfcMassDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcMassDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcMassFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[634]); }
 void Ifc4x3::IfcMassFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcMassFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[635]); }
 void Ifc4x3::IfcMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassPerLengthMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcMassPerLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[636]); }
 void Ifc4x3::IfcMassPerLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcMassPerLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfElasticityMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcModulusOfElasticityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[674]); }
 void Ifc4x3::IfcModulusOfElasticityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcModulusOfElasticityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfLinearSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcModulusOfLinearSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[675]); }
 void Ifc4x3::IfcModulusOfLinearSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcModulusOfLinearSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfRotationalSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcModulusOfRotationalSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[676]); }
 void Ifc4x3::IfcModulusOfRotationalSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcModulusOfRotationalSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcModulusOfSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[678]); }
 void Ifc4x3::IfcModulusOfSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcModulusOfSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMoistureDiffusivityMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcMoistureDiffusivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[681]); }
 void Ifc4x3::IfcMoistureDiffusivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcMoistureDiffusivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMolecularWeightMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcMolecularWeightMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[682]); }
 void Ifc4x3::IfcMolecularWeightMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcMolecularWeightMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMomentOfInertiaMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcMomentOfInertiaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[683]); }
 void Ifc4x3::IfcMomentOfInertiaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcMomentOfInertiaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonetaryMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcMonetaryMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[684]); }
 void Ifc4x3::IfcMonetaryMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcMonetaryMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonthInYearNumber
 const IfcParse::type_declaration& Ifc4x3::IfcMonthInYearNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[686]); }
 void Ifc4x3::IfcMonthInYearNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcMonthInYearNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNonNegativeLengthMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcNonNegativeLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[697]); }
+void Ifc4x3::IfcNonNegativeLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3::IfcNonNegativeLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNormalisedRatioMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcNormalisedRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[698]); }
+void Ifc4x3::IfcNormalisedRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3::IfcNormalisedRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNumericMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcNumericMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[699]); }
 void Ifc4x3::IfcNumericMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcNumericMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPHMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcPHMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[740]); }
 void Ifc4x3::IfcPHMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcPHMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcParameterValue
 const IfcParse::type_declaration& Ifc4x3::IfcParameterValue::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[726]); }
 void Ifc4x3::IfcParameterValue::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcParameterValue::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlanarForceMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcPlanarForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[759]); }
 void Ifc4x3::IfcPlanarForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcPlanarForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[761]); }
 void Ifc4x3::IfcPlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcPlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveInteger
 const IfcParse::type_declaration& Ifc4x3::IfcPositiveInteger::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[777]); }
+void Ifc4x3::IfcPositiveInteger::initialize(int v) { set_attribute_value(0, (v)); }
 Ifc4x3::IfcPositiveInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveLengthMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcPositiveLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[778]); }
+void Ifc4x3::IfcPositiveLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3::IfcPositiveLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositivePlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcPositivePlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[779]); }
+void Ifc4x3::IfcPositivePlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3::IfcPositivePlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveRatioMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcPositiveRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[780]); }
+void Ifc4x3::IfcPositiveRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3::IfcPositiveRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPowerMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[782]); }
 void Ifc4x3::IfcPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPresentableText
 const IfcParse::type_declaration& Ifc4x3::IfcPresentableText::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[790]); }
 void Ifc4x3::IfcPresentableText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcPresentableText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPressureMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[795]); }
 void Ifc4x3::IfcPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPropertySetDefinitionSet
 const IfcParse::type_declaration& Ifc4x3::IfcPropertySetDefinitionSet::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[829]); }
 void Ifc4x3::IfcPropertySetDefinitionSet::initialize(std::vector< ::Ifc4x3::IfcPropertySetDefinition > v) { set_attribute_value(0, cast_vector<express::Base>(v)); }
+Ifc4x3::IfcPropertySetDefinitionSet::operator std::vector< ::Ifc4x3::IfcPropertySetDefinition >() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4x3::IfcPropertySetDefinition>(es); }
 
 // Function implementations for IfcRadioActivityMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcRadioActivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[853]); }
 void Ifc4x3::IfcRadioActivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcRadioActivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRatioMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[870]); }
 void Ifc4x3::IfcRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcReal
 const IfcParse::type_declaration& Ifc4x3::IfcReal::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[873]); }
 void Ifc4x3::IfcReal::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcReal::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcRotationalFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[975]); }
 void Ifc4x3::IfcRotationalFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcRotationalFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalMassMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcRotationalMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[976]); }
 void Ifc4x3::IfcRotationalMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcRotationalMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcRotationalStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[977]); }
 void Ifc4x3::IfcRotationalStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcRotationalStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionModulusMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcSectionModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[991]); }
 void Ifc4x3::IfcSectionModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcSectionModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionalAreaIntegralMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcSectionalAreaIntegralMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[986]); }
 void Ifc4x3::IfcSectionalAreaIntegralMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcSectionalAreaIntegralMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcShearModulusMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcShearModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1009]); }
 void Ifc4x3::IfcShearModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcShearModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSolidAngleMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcSolidAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1035]); }
 void Ifc4x3::IfcSolidAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcSolidAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerLevelMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcSoundPowerLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1038]); }
 void Ifc4x3::IfcSoundPowerLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcSoundPowerLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcSoundPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1039]); }
 void Ifc4x3::IfcSoundPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcSoundPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureLevelMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcSoundPressureLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1040]); }
 void Ifc4x3::IfcSoundPressureLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcSoundPressureLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcSoundPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1041]); }
 void Ifc4x3::IfcSoundPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcSoundPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecificHeatCapacityMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcSpecificHeatCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1057]); }
 void Ifc4x3::IfcSpecificHeatCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcSpecificHeatCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularExponent
 const IfcParse::type_declaration& Ifc4x3::IfcSpecularExponent::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1058]); }
 void Ifc4x3::IfcSpecularExponent::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcSpecularExponent::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularRoughness
 const IfcParse::type_declaration& Ifc4x3::IfcSpecularRoughness::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1060]); }
 void Ifc4x3::IfcSpecularRoughness::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcSpecularRoughness::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureGradientMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcTemperatureGradientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1165]); }
 void Ifc4x3::IfcTemperatureGradientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcTemperatureGradientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureRateOfChangeMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcTemperatureRateOfChangeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1166]); }
 void Ifc4x3::IfcTemperatureRateOfChangeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcTemperatureRateOfChangeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcText
 const IfcParse::type_declaration& Ifc4x3::IfcText::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1178]); }
 void Ifc4x3::IfcText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextAlignment
 const IfcParse::type_declaration& Ifc4x3::IfcTextAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1179]); }
 void Ifc4x3::IfcTextAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcTextAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextDecoration
 const IfcParse::type_declaration& Ifc4x3::IfcTextDecoration::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1180]); }
 void Ifc4x3::IfcTextDecoration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcTextDecoration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextFontName
 const IfcParse::type_declaration& Ifc4x3::IfcTextFontName::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1181]); }
 void Ifc4x3::IfcTextFontName::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcTextFontName::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextTransformation
 const IfcParse::type_declaration& Ifc4x3::IfcTextTransformation::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1190]); }
 void Ifc4x3::IfcTextTransformation::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcTextTransformation::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalAdmittanceMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcThermalAdmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1198]); }
 void Ifc4x3::IfcThermalAdmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcThermalAdmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalConductivityMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcThermalConductivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1199]); }
 void Ifc4x3::IfcThermalConductivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcThermalConductivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalExpansionCoefficientMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcThermalExpansionCoefficientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1200]); }
 void Ifc4x3::IfcThermalExpansionCoefficientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcThermalExpansionCoefficientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalResistanceMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcThermalResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1201]); }
 void Ifc4x3::IfcThermalResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcThermalResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalTransmittanceMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcThermalTransmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1202]); }
 void Ifc4x3::IfcThermalTransmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcThermalTransmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermodynamicTemperatureMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcThermodynamicTemperatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1203]); }
 void Ifc4x3::IfcThermodynamicTemperatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcThermodynamicTemperatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTime
 const IfcParse::type_declaration& Ifc4x3::IfcTime::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1205]); }
 void Ifc4x3::IfcTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcTimeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1206]); }
 void Ifc4x3::IfcTimeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcTimeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeStamp
 const IfcParse::type_declaration& Ifc4x3::IfcTimeStamp::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1212]); }
 void Ifc4x3::IfcTimeStamp::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcTimeStamp::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTorqueMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcTorqueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1216]); }
 void Ifc4x3::IfcTorqueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcTorqueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcURIReference
 const IfcParse::type_declaration& Ifc4x3::IfcURIReference::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1253]); }
 void Ifc4x3::IfcURIReference::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcURIReference::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVaporPermeabilityMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcVaporPermeabilityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1259]); }
 void Ifc4x3::IfcVaporPermeabilityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcVaporPermeabilityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumeMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcVolumeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1279]); }
 void Ifc4x3::IfcVolumeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcVolumeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumetricFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcVolumetricFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1280]); }
 void Ifc4x3::IfcVolumetricFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcVolumetricFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingConstantMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcWarpingConstantMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1285]); }
 void Ifc4x3::IfcWarpingConstantMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcWarpingConstantMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingMomentMeasure
 const IfcParse::type_declaration& Ifc4x3::IfcWarpingMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_types[1286]); }
 void Ifc4x3::IfcWarpingMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3::IfcWarpingMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 
 // Function implementations for IfcActionRequest
@@ -8391,8 +8521,8 @@ int Ifc4x3::IfcBSplineSurface::UDegree() const {  int v = get_attribute_value(0)
 void Ifc4x3::IfcBSplineSurface::setUDegree(const int& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
 int Ifc4x3::IfcBSplineSurface::VDegree() const {  int v = get_attribute_value(1); return v; }
 void Ifc4x3::IfcBSplineSurface::setVDegree(const int& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
-std::vector< std::vector< ::Ifc4x3::IfcCartesianPoint > > Ifc4x3::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector_vector<::Ifc4x3::IfcCartesianPoint>(es); }
-void Ifc4x3::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x3::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
+std::vector< std::vector< ::Ifc4x3::IfcCartesianPoint > > Ifc4x3::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector<::Ifc4x3::IfcCartesianPoint>(es); }
+void Ifc4x3::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x3::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
 ::Ifc4x3::IfcBSplineSurfaceForm::Value Ifc4x3::IfcBSplineSurface::SurfaceForm() const {  return ::Ifc4x3::IfcBSplineSurfaceForm::FromString(get_attribute_value(3)); }
 void Ifc4x3::IfcBSplineSurface::setSurfaceForm(const ::Ifc4x3::IfcBSplineSurfaceForm::Value& v) { set_attribute_value(3, EnumerationReference(&::Ifc4x3::IfcBSplineSurfaceForm::Class(), (size_t) v));if constexpr (false)unset_attribute_value(3); }
 boost::logic::tribool Ifc4x3::IfcBSplineSurface::UClosed() const {  boost::logic::tribool v = get_attribute_value(4); return v; }
diff --git a/src/ifcparse/Ifc4x3_add1.cpp b/src/ifcparse/Ifc4x3_add1.cpp
index c43c9dfc3d..0647941123 100644
--- a/src/ifcparse/Ifc4x3_add1.cpp
+++ b/src/ifcparse/Ifc4x3_add1.cpp
@@ -7212,530 +7212,662 @@ const IfcParse::select_type& Ifc4x3_add1::IfcWarpingStiffnessSelect::Class() { r
 // Function implementations for IfcAbsorbedDoseMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcAbsorbedDoseMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[0]); }
 void Ifc4x3_add1::IfcAbsorbedDoseMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcAbsorbedDoseMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAccelerationMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcAccelerationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1]); }
 void Ifc4x3_add1::IfcAccelerationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcAccelerationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAmountOfSubstanceMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcAmountOfSubstanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[42]); }
 void Ifc4x3_add1::IfcAmountOfSubstanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcAmountOfSubstanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAngularVelocityMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcAngularVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[45]); }
 void Ifc4x3_add1::IfcAngularVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcAngularVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcArcIndex
 const IfcParse::type_declaration& Ifc4x3_add1::IfcArcIndex::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[57]); }
 void Ifc4x3_add1::IfcArcIndex::initialize(std::vector< int > /*[3:3]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcArcIndex::operator std::vector< int > /*[3:3]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcAreaDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[58]); }
 void Ifc4x3_add1::IfcAreaDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcAreaDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcAreaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[59]); }
 void Ifc4x3_add1::IfcAreaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcAreaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBinary
 const IfcParse::type_declaration& Ifc4x3_add1::IfcBinary::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[80]); }
 void Ifc4x3_add1::IfcBinary::initialize(boost::dynamic_bitset<> v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcBinary::operator boost::dynamic_bitset<>() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoolean
 const IfcParse::type_declaration& Ifc4x3_add1::IfcBoolean::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[86]); }
 void Ifc4x3_add1::IfcBoolean::initialize(bool v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcBoolean::operator bool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoxAlignment
 const IfcParse::type_declaration& Ifc4x3_add1::IfcBoxAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[101]); }
+void Ifc4x3_add1::IfcBoxAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x3_add1::IfcBoxAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCardinalPointReference
 const IfcParse::type_declaration& Ifc4x3_add1::IfcCardinalPointReference::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[145]); }
 void Ifc4x3_add1::IfcCardinalPointReference::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcCardinalPointReference::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcComplexNumber
 const IfcParse::type_declaration& Ifc4x3_add1::IfcComplexNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[188]); }
 void Ifc4x3_add1::IfcComplexNumber::initialize(std::vector< double > /*[1:2]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcComplexNumber::operator std::vector< double > /*[1:2]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCompoundPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcCompoundPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[196]); }
 void Ifc4x3_add1::IfcCompoundPlaneAngleMeasure::initialize(std::vector< int > /*[3:4]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcCompoundPlaneAngleMeasure::operator std::vector< int > /*[3:4]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcContextDependentMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcContextDependentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[226]); }
 void Ifc4x3_add1::IfcContextDependentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcContextDependentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCountMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcCountMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[252]); }
 void Ifc4x3_add1::IfcCountMeasure::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcCountMeasure::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCurvatureMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcCurvatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[270]); }
 void Ifc4x3_add1::IfcCurvatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcCurvatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDate
 const IfcParse::type_declaration& Ifc4x3_add1::IfcDate::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[290]); }
 void Ifc4x3_add1::IfcDate::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcDate::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDateTime
 const IfcParse::type_declaration& Ifc4x3_add1::IfcDateTime::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[291]); }
 void Ifc4x3_add1::IfcDateTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcDateTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInMonthNumber
 const IfcParse::type_declaration& Ifc4x3_add1::IfcDayInMonthNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[292]); }
 void Ifc4x3_add1::IfcDayInMonthNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcDayInMonthNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInWeekNumber
 const IfcParse::type_declaration& Ifc4x3_add1::IfcDayInWeekNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[293]); }
 void Ifc4x3_add1::IfcDayInWeekNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcDayInWeekNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDescriptiveMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcDescriptiveMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[302]); }
 void Ifc4x3_add1::IfcDescriptiveMeasure::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcDescriptiveMeasure::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDimensionCount
 const IfcParse::type_declaration& Ifc4x3_add1::IfcDimensionCount::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[304]); }
 void Ifc4x3_add1::IfcDimensionCount::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcDimensionCount::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDoseEquivalentMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcDoseEquivalentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[343]); }
 void Ifc4x3_add1::IfcDoseEquivalentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcDoseEquivalentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDuration
 const IfcParse::type_declaration& Ifc4x3_add1::IfcDuration::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[355]); }
 void Ifc4x3_add1::IfcDuration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcDuration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDynamicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcDynamicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[356]); }
 void Ifc4x3_add1::IfcDynamicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcDynamicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCapacitanceMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcElectricCapacitanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[368]); }
 void Ifc4x3_add1::IfcElectricCapacitanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcElectricCapacitanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricChargeMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcElectricChargeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[369]); }
 void Ifc4x3_add1::IfcElectricChargeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcElectricChargeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricConductanceMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcElectricConductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[370]); }
 void Ifc4x3_add1::IfcElectricConductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcElectricConductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCurrentMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcElectricCurrentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[371]); }
 void Ifc4x3_add1::IfcElectricCurrentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcElectricCurrentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricResistanceMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcElectricResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[387]); }
 void Ifc4x3_add1::IfcElectricResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcElectricResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricVoltageMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcElectricVoltageMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[391]); }
 void Ifc4x3_add1::IfcElectricVoltageMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcElectricVoltageMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcEnergyMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcEnergyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[406]); }
 void Ifc4x3_add1::IfcEnergyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcEnergyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontStyle
 const IfcParse::type_declaration& Ifc4x3_add1::IfcFontStyle::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[487]); }
 void Ifc4x3_add1::IfcFontStyle::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcFontStyle::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontVariant
 const IfcParse::type_declaration& Ifc4x3_add1::IfcFontVariant::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[488]); }
 void Ifc4x3_add1::IfcFontVariant::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcFontVariant::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontWeight
 const IfcParse::type_declaration& Ifc4x3_add1::IfcFontWeight::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[489]); }
 void Ifc4x3_add1::IfcFontWeight::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcFontWeight::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcForceMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[493]); }
 void Ifc4x3_add1::IfcForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[494]); }
 void Ifc4x3_add1::IfcFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcGloballyUniqueId
 const IfcParse::type_declaration& Ifc4x3_add1::IfcGloballyUniqueId::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[517]); }
 void Ifc4x3_add1::IfcGloballyUniqueId::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcGloballyUniqueId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcHeatFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[531]); }
 void Ifc4x3_add1::IfcHeatFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcHeatFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatingValueMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcHeatingValueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[532]); }
 void Ifc4x3_add1::IfcHeatingValueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcHeatingValueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIdentifier
 const IfcParse::type_declaration& Ifc4x3_add1::IfcIdentifier::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[536]); }
 void Ifc4x3_add1::IfcIdentifier::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcIdentifier::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIlluminanceMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcIlluminanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[537]); }
 void Ifc4x3_add1::IfcIlluminanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcIlluminanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInductanceMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcInductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[549]); }
 void Ifc4x3_add1::IfcInductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcInductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInteger
 const IfcParse::type_declaration& Ifc4x3_add1::IfcInteger::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[550]); }
 void Ifc4x3_add1::IfcInteger::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIntegerCountRateMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcIntegerCountRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[551]); }
 void Ifc4x3_add1::IfcIntegerCountRateMeasure::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcIntegerCountRateMeasure::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIonConcentrationMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcIonConcentrationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[560]); }
 void Ifc4x3_add1::IfcIonConcentrationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcIonConcentrationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIsothermalMoistureCapacityMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcIsothermalMoistureCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[564]); }
 void Ifc4x3_add1::IfcIsothermalMoistureCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcIsothermalMoistureCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcKinematicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcKinematicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[571]); }
 void Ifc4x3_add1::IfcKinematicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcKinematicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLabel
 const IfcParse::type_declaration& Ifc4x3_add1::IfcLabel::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[573]); }
 void Ifc4x3_add1::IfcLabel::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcLabel::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLanguageId
 const IfcParse::type_declaration& Ifc4x3_add1::IfcLanguageId::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[581]); }
+void Ifc4x3_add1::IfcLanguageId::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x3_add1::IfcLanguageId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[584]); }
 void Ifc4x3_add1::IfcLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLineIndex
 const IfcParse::type_declaration& Ifc4x3_add1::IfcLineIndex::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[610]); }
 void Ifc4x3_add1::IfcLineIndex::initialize(std::vector< int > /*[2:?]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcLineIndex::operator std::vector< int > /*[2:?]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearForceMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcLinearForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[604]); }
 void Ifc4x3_add1::IfcLinearForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcLinearForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearMomentMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcLinearMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[605]); }
 void Ifc4x3_add1::IfcLinearMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcLinearMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcLinearStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[608]); }
 void Ifc4x3_add1::IfcLinearStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcLinearStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearVelocityMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcLinearVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[609]); }
 void Ifc4x3_add1::IfcLinearVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcLinearVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLogical
 const IfcParse::type_declaration& Ifc4x3_add1::IfcLogical::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[616]); }
 void Ifc4x3_add1::IfcLogical::initialize(boost::logic::tribool v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcLogical::operator boost::logic::tribool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousFluxMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcLuminousFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[620]); }
 void Ifc4x3_add1::IfcLuminousFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcLuminousFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityDistributionMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcLuminousIntensityDistributionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[621]); }
 void Ifc4x3_add1::IfcLuminousIntensityDistributionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcLuminousIntensityDistributionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcLuminousIntensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[622]); }
 void Ifc4x3_add1::IfcLuminousIntensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcLuminousIntensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcMagneticFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[623]); }
 void Ifc4x3_add1::IfcMagneticFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcMagneticFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcMagneticFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[624]); }
 void Ifc4x3_add1::IfcMagneticFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcMagneticFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcMassDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[633]); }
 void Ifc4x3_add1::IfcMassDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcMassDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcMassFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[634]); }
 void Ifc4x3_add1::IfcMassFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcMassFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[635]); }
 void Ifc4x3_add1::IfcMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassPerLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcMassPerLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[636]); }
 void Ifc4x3_add1::IfcMassPerLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcMassPerLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfElasticityMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcModulusOfElasticityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[674]); }
 void Ifc4x3_add1::IfcModulusOfElasticityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcModulusOfElasticityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfLinearSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcModulusOfLinearSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[675]); }
 void Ifc4x3_add1::IfcModulusOfLinearSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcModulusOfLinearSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfRotationalSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcModulusOfRotationalSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[676]); }
 void Ifc4x3_add1::IfcModulusOfRotationalSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcModulusOfRotationalSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcModulusOfSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[678]); }
 void Ifc4x3_add1::IfcModulusOfSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcModulusOfSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMoistureDiffusivityMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcMoistureDiffusivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[681]); }
 void Ifc4x3_add1::IfcMoistureDiffusivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcMoistureDiffusivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMolecularWeightMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcMolecularWeightMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[682]); }
 void Ifc4x3_add1::IfcMolecularWeightMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcMolecularWeightMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMomentOfInertiaMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcMomentOfInertiaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[683]); }
 void Ifc4x3_add1::IfcMomentOfInertiaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcMomentOfInertiaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonetaryMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcMonetaryMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[684]); }
 void Ifc4x3_add1::IfcMonetaryMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcMonetaryMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonthInYearNumber
 const IfcParse::type_declaration& Ifc4x3_add1::IfcMonthInYearNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[686]); }
 void Ifc4x3_add1::IfcMonthInYearNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcMonthInYearNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNonNegativeLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcNonNegativeLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[697]); }
+void Ifc4x3_add1::IfcNonNegativeLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_add1::IfcNonNegativeLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNormalisedRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcNormalisedRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[698]); }
+void Ifc4x3_add1::IfcNormalisedRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_add1::IfcNormalisedRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNumericMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcNumericMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[699]); }
 void Ifc4x3_add1::IfcNumericMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcNumericMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPHMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcPHMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[739]); }
 void Ifc4x3_add1::IfcPHMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcPHMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcParameterValue
 const IfcParse::type_declaration& Ifc4x3_add1::IfcParameterValue::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[725]); }
 void Ifc4x3_add1::IfcParameterValue::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcParameterValue::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlanarForceMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcPlanarForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[758]); }
 void Ifc4x3_add1::IfcPlanarForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcPlanarForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[760]); }
 void Ifc4x3_add1::IfcPlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcPlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveInteger
 const IfcParse::type_declaration& Ifc4x3_add1::IfcPositiveInteger::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[776]); }
+void Ifc4x3_add1::IfcPositiveInteger::initialize(int v) { set_attribute_value(0, (v)); }
 Ifc4x3_add1::IfcPositiveInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcPositiveLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[777]); }
+void Ifc4x3_add1::IfcPositiveLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_add1::IfcPositiveLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositivePlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcPositivePlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[778]); }
+void Ifc4x3_add1::IfcPositivePlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_add1::IfcPositivePlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcPositiveRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[779]); }
+void Ifc4x3_add1::IfcPositiveRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_add1::IfcPositiveRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPowerMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[781]); }
 void Ifc4x3_add1::IfcPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPresentableText
 const IfcParse::type_declaration& Ifc4x3_add1::IfcPresentableText::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[789]); }
 void Ifc4x3_add1::IfcPresentableText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcPresentableText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPressureMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[794]); }
 void Ifc4x3_add1::IfcPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPropertySetDefinitionSet
 const IfcParse::type_declaration& Ifc4x3_add1::IfcPropertySetDefinitionSet::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[828]); }
 void Ifc4x3_add1::IfcPropertySetDefinitionSet::initialize(std::vector< ::Ifc4x3_add1::IfcPropertySetDefinition > v) { set_attribute_value(0, cast_vector<express::Base>(v)); }
+Ifc4x3_add1::IfcPropertySetDefinitionSet::operator std::vector< ::Ifc4x3_add1::IfcPropertySetDefinition >() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4x3_add1::IfcPropertySetDefinition>(es); }
 
 // Function implementations for IfcRadioActivityMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcRadioActivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[852]); }
 void Ifc4x3_add1::IfcRadioActivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcRadioActivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[869]); }
 void Ifc4x3_add1::IfcRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcReal
 const IfcParse::type_declaration& Ifc4x3_add1::IfcReal::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[872]); }
 void Ifc4x3_add1::IfcReal::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcReal::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcRotationalFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[975]); }
 void Ifc4x3_add1::IfcRotationalFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcRotationalFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalMassMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcRotationalMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[976]); }
 void Ifc4x3_add1::IfcRotationalMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcRotationalMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcRotationalStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[977]); }
 void Ifc4x3_add1::IfcRotationalStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcRotationalStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionModulusMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcSectionModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[991]); }
 void Ifc4x3_add1::IfcSectionModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcSectionModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionalAreaIntegralMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcSectionalAreaIntegralMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[986]); }
 void Ifc4x3_add1::IfcSectionalAreaIntegralMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcSectionalAreaIntegralMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcShearModulusMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcShearModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1009]); }
 void Ifc4x3_add1::IfcShearModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcShearModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSolidAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcSolidAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1035]); }
 void Ifc4x3_add1::IfcSolidAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcSolidAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerLevelMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcSoundPowerLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1038]); }
 void Ifc4x3_add1::IfcSoundPowerLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcSoundPowerLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcSoundPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1039]); }
 void Ifc4x3_add1::IfcSoundPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcSoundPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureLevelMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcSoundPressureLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1040]); }
 void Ifc4x3_add1::IfcSoundPressureLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcSoundPressureLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcSoundPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1041]); }
 void Ifc4x3_add1::IfcSoundPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcSoundPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecificHeatCapacityMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcSpecificHeatCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1057]); }
 void Ifc4x3_add1::IfcSpecificHeatCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcSpecificHeatCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularExponent
 const IfcParse::type_declaration& Ifc4x3_add1::IfcSpecularExponent::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1058]); }
 void Ifc4x3_add1::IfcSpecularExponent::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcSpecularExponent::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularRoughness
 const IfcParse::type_declaration& Ifc4x3_add1::IfcSpecularRoughness::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1060]); }
 void Ifc4x3_add1::IfcSpecularRoughness::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcSpecularRoughness::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcStrippedOptional
 const IfcParse::type_declaration& Ifc4x3_add1::IfcStrippedOptional::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1074]); }
 void Ifc4x3_add1::IfcStrippedOptional::initialize(bool v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcStrippedOptional::operator bool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureGradientMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcTemperatureGradientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1166]); }
 void Ifc4x3_add1::IfcTemperatureGradientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcTemperatureGradientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureRateOfChangeMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcTemperatureRateOfChangeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1167]); }
 void Ifc4x3_add1::IfcTemperatureRateOfChangeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcTemperatureRateOfChangeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcText
 const IfcParse::type_declaration& Ifc4x3_add1::IfcText::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1179]); }
 void Ifc4x3_add1::IfcText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextAlignment
 const IfcParse::type_declaration& Ifc4x3_add1::IfcTextAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1180]); }
 void Ifc4x3_add1::IfcTextAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcTextAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextDecoration
 const IfcParse::type_declaration& Ifc4x3_add1::IfcTextDecoration::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1181]); }
 void Ifc4x3_add1::IfcTextDecoration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcTextDecoration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextFontName
 const IfcParse::type_declaration& Ifc4x3_add1::IfcTextFontName::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1182]); }
 void Ifc4x3_add1::IfcTextFontName::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcTextFontName::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextTransformation
 const IfcParse::type_declaration& Ifc4x3_add1::IfcTextTransformation::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1191]); }
 void Ifc4x3_add1::IfcTextTransformation::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcTextTransformation::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalAdmittanceMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcThermalAdmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1199]); }
 void Ifc4x3_add1::IfcThermalAdmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcThermalAdmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalConductivityMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcThermalConductivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1200]); }
 void Ifc4x3_add1::IfcThermalConductivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcThermalConductivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalExpansionCoefficientMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcThermalExpansionCoefficientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1201]); }
 void Ifc4x3_add1::IfcThermalExpansionCoefficientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcThermalExpansionCoefficientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalResistanceMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcThermalResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1202]); }
 void Ifc4x3_add1::IfcThermalResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcThermalResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalTransmittanceMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcThermalTransmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1203]); }
 void Ifc4x3_add1::IfcThermalTransmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcThermalTransmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermodynamicTemperatureMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcThermodynamicTemperatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1204]); }
 void Ifc4x3_add1::IfcThermodynamicTemperatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcThermodynamicTemperatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTime
 const IfcParse::type_declaration& Ifc4x3_add1::IfcTime::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1206]); }
 void Ifc4x3_add1::IfcTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcTimeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1207]); }
 void Ifc4x3_add1::IfcTimeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcTimeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeStamp
 const IfcParse::type_declaration& Ifc4x3_add1::IfcTimeStamp::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1213]); }
 void Ifc4x3_add1::IfcTimeStamp::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcTimeStamp::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTorqueMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcTorqueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1217]); }
 void Ifc4x3_add1::IfcTorqueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcTorqueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcURIReference
 const IfcParse::type_declaration& Ifc4x3_add1::IfcURIReference::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1254]); }
 void Ifc4x3_add1::IfcURIReference::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcURIReference::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVaporPermeabilityMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcVaporPermeabilityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1260]); }
 void Ifc4x3_add1::IfcVaporPermeabilityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcVaporPermeabilityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumeMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcVolumeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1280]); }
 void Ifc4x3_add1::IfcVolumeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcVolumeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumetricFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcVolumetricFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1281]); }
 void Ifc4x3_add1::IfcVolumetricFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcVolumetricFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingConstantMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcWarpingConstantMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1286]); }
 void Ifc4x3_add1::IfcWarpingConstantMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcWarpingConstantMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingMomentMeasure
 const IfcParse::type_declaration& Ifc4x3_add1::IfcWarpingMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1287]); }
 void Ifc4x3_add1::IfcWarpingMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcWarpingMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWellKnownTextLiteral
 const IfcParse::type_declaration& Ifc4x3_add1::IfcWellKnownTextLiteral::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD1_types[1293]); }
 void Ifc4x3_add1::IfcWellKnownTextLiteral::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add1::IfcWellKnownTextLiteral::operator std::string() const { return get_attribute_value(0); }
 
 
 // Function implementations for IfcActionRequest
@@ -8254,8 +8386,8 @@ int Ifc4x3_add1::IfcBSplineSurface::UDegree() const {  int v = get_attribute_val
 void Ifc4x3_add1::IfcBSplineSurface::setUDegree(const int& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
 int Ifc4x3_add1::IfcBSplineSurface::VDegree() const {  int v = get_attribute_value(1); return v; }
 void Ifc4x3_add1::IfcBSplineSurface::setVDegree(const int& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
-std::vector< std::vector< ::Ifc4x3_add1::IfcCartesianPoint > > Ifc4x3_add1::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector_vector<::Ifc4x3_add1::IfcCartesianPoint>(es); }
-void Ifc4x3_add1::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x3_add1::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
+std::vector< std::vector< ::Ifc4x3_add1::IfcCartesianPoint > > Ifc4x3_add1::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector<::Ifc4x3_add1::IfcCartesianPoint>(es); }
+void Ifc4x3_add1::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x3_add1::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
 ::Ifc4x3_add1::IfcBSplineSurfaceForm::Value Ifc4x3_add1::IfcBSplineSurface::SurfaceForm() const {  return ::Ifc4x3_add1::IfcBSplineSurfaceForm::FromString(get_attribute_value(3)); }
 void Ifc4x3_add1::IfcBSplineSurface::setSurfaceForm(const ::Ifc4x3_add1::IfcBSplineSurfaceForm::Value& v) { set_attribute_value(3, EnumerationReference(&::Ifc4x3_add1::IfcBSplineSurfaceForm::Class(), (size_t) v));if constexpr (false)unset_attribute_value(3); }
 boost::logic::tribool Ifc4x3_add1::IfcBSplineSurface::UClosed() const {  boost::logic::tribool v = get_attribute_value(4); return v; }
diff --git a/src/ifcparse/Ifc4x3_add2.cpp b/src/ifcparse/Ifc4x3_add2.cpp
index 1c6a96b2b9..6832392825 100644
--- a/src/ifcparse/Ifc4x3_add2.cpp
+++ b/src/ifcparse/Ifc4x3_add2.cpp
@@ -7212,530 +7212,662 @@ const IfcParse::select_type& Ifc4x3_add2::IfcWarpingStiffnessSelect::Class() { r
 // Function implementations for IfcAbsorbedDoseMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcAbsorbedDoseMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[0]); }
 void Ifc4x3_add2::IfcAbsorbedDoseMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcAbsorbedDoseMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAccelerationMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcAccelerationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1]); }
 void Ifc4x3_add2::IfcAccelerationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcAccelerationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAmountOfSubstanceMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcAmountOfSubstanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[42]); }
 void Ifc4x3_add2::IfcAmountOfSubstanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcAmountOfSubstanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAngularVelocityMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcAngularVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[45]); }
 void Ifc4x3_add2::IfcAngularVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcAngularVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcArcIndex
 const IfcParse::type_declaration& Ifc4x3_add2::IfcArcIndex::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[57]); }
 void Ifc4x3_add2::IfcArcIndex::initialize(std::vector< int > /*[3:3]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcArcIndex::operator std::vector< int > /*[3:3]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcAreaDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[58]); }
 void Ifc4x3_add2::IfcAreaDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcAreaDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcAreaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[59]); }
 void Ifc4x3_add2::IfcAreaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcAreaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBinary
 const IfcParse::type_declaration& Ifc4x3_add2::IfcBinary::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[80]); }
 void Ifc4x3_add2::IfcBinary::initialize(boost::dynamic_bitset<> v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcBinary::operator boost::dynamic_bitset<>() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoolean
 const IfcParse::type_declaration& Ifc4x3_add2::IfcBoolean::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[86]); }
 void Ifc4x3_add2::IfcBoolean::initialize(bool v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcBoolean::operator bool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoxAlignment
 const IfcParse::type_declaration& Ifc4x3_add2::IfcBoxAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[101]); }
+void Ifc4x3_add2::IfcBoxAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x3_add2::IfcBoxAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCardinalPointReference
 const IfcParse::type_declaration& Ifc4x3_add2::IfcCardinalPointReference::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[145]); }
 void Ifc4x3_add2::IfcCardinalPointReference::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcCardinalPointReference::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcComplexNumber
 const IfcParse::type_declaration& Ifc4x3_add2::IfcComplexNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[188]); }
 void Ifc4x3_add2::IfcComplexNumber::initialize(std::vector< double > /*[1:2]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcComplexNumber::operator std::vector< double > /*[1:2]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCompoundPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcCompoundPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[196]); }
 void Ifc4x3_add2::IfcCompoundPlaneAngleMeasure::initialize(std::vector< int > /*[3:4]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcCompoundPlaneAngleMeasure::operator std::vector< int > /*[3:4]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcContextDependentMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcContextDependentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[226]); }
 void Ifc4x3_add2::IfcContextDependentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcContextDependentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCountMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcCountMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[252]); }
 void Ifc4x3_add2::IfcCountMeasure::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcCountMeasure::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCurvatureMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcCurvatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[270]); }
 void Ifc4x3_add2::IfcCurvatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcCurvatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDate
 const IfcParse::type_declaration& Ifc4x3_add2::IfcDate::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[290]); }
 void Ifc4x3_add2::IfcDate::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcDate::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDateTime
 const IfcParse::type_declaration& Ifc4x3_add2::IfcDateTime::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[291]); }
 void Ifc4x3_add2::IfcDateTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcDateTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInMonthNumber
 const IfcParse::type_declaration& Ifc4x3_add2::IfcDayInMonthNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[292]); }
 void Ifc4x3_add2::IfcDayInMonthNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcDayInMonthNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInWeekNumber
 const IfcParse::type_declaration& Ifc4x3_add2::IfcDayInWeekNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[293]); }
 void Ifc4x3_add2::IfcDayInWeekNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcDayInWeekNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDescriptiveMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcDescriptiveMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[302]); }
 void Ifc4x3_add2::IfcDescriptiveMeasure::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcDescriptiveMeasure::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDimensionCount
 const IfcParse::type_declaration& Ifc4x3_add2::IfcDimensionCount::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[304]); }
 void Ifc4x3_add2::IfcDimensionCount::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcDimensionCount::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDoseEquivalentMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcDoseEquivalentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[343]); }
 void Ifc4x3_add2::IfcDoseEquivalentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcDoseEquivalentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDuration
 const IfcParse::type_declaration& Ifc4x3_add2::IfcDuration::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[355]); }
 void Ifc4x3_add2::IfcDuration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcDuration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDynamicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcDynamicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[356]); }
 void Ifc4x3_add2::IfcDynamicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcDynamicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCapacitanceMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcElectricCapacitanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[368]); }
 void Ifc4x3_add2::IfcElectricCapacitanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcElectricCapacitanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricChargeMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcElectricChargeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[369]); }
 void Ifc4x3_add2::IfcElectricChargeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcElectricChargeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricConductanceMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcElectricConductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[370]); }
 void Ifc4x3_add2::IfcElectricConductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcElectricConductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCurrentMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcElectricCurrentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[371]); }
 void Ifc4x3_add2::IfcElectricCurrentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcElectricCurrentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricResistanceMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcElectricResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[387]); }
 void Ifc4x3_add2::IfcElectricResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcElectricResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricVoltageMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcElectricVoltageMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[391]); }
 void Ifc4x3_add2::IfcElectricVoltageMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcElectricVoltageMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcEnergyMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcEnergyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[406]); }
 void Ifc4x3_add2::IfcEnergyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcEnergyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontStyle
 const IfcParse::type_declaration& Ifc4x3_add2::IfcFontStyle::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[487]); }
 void Ifc4x3_add2::IfcFontStyle::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcFontStyle::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontVariant
 const IfcParse::type_declaration& Ifc4x3_add2::IfcFontVariant::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[488]); }
 void Ifc4x3_add2::IfcFontVariant::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcFontVariant::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontWeight
 const IfcParse::type_declaration& Ifc4x3_add2::IfcFontWeight::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[489]); }
 void Ifc4x3_add2::IfcFontWeight::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcFontWeight::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcForceMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[493]); }
 void Ifc4x3_add2::IfcForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[494]); }
 void Ifc4x3_add2::IfcFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcGloballyUniqueId
 const IfcParse::type_declaration& Ifc4x3_add2::IfcGloballyUniqueId::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[517]); }
 void Ifc4x3_add2::IfcGloballyUniqueId::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcGloballyUniqueId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcHeatFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[531]); }
 void Ifc4x3_add2::IfcHeatFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcHeatFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatingValueMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcHeatingValueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[532]); }
 void Ifc4x3_add2::IfcHeatingValueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcHeatingValueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIdentifier
 const IfcParse::type_declaration& Ifc4x3_add2::IfcIdentifier::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[536]); }
 void Ifc4x3_add2::IfcIdentifier::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcIdentifier::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIlluminanceMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcIlluminanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[537]); }
 void Ifc4x3_add2::IfcIlluminanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcIlluminanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInductanceMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcInductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[549]); }
 void Ifc4x3_add2::IfcInductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcInductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInteger
 const IfcParse::type_declaration& Ifc4x3_add2::IfcInteger::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[550]); }
 void Ifc4x3_add2::IfcInteger::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIntegerCountRateMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcIntegerCountRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[551]); }
 void Ifc4x3_add2::IfcIntegerCountRateMeasure::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcIntegerCountRateMeasure::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIonConcentrationMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcIonConcentrationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[560]); }
 void Ifc4x3_add2::IfcIonConcentrationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcIonConcentrationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIsothermalMoistureCapacityMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcIsothermalMoistureCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[564]); }
 void Ifc4x3_add2::IfcIsothermalMoistureCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcIsothermalMoistureCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcKinematicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcKinematicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[571]); }
 void Ifc4x3_add2::IfcKinematicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcKinematicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLabel
 const IfcParse::type_declaration& Ifc4x3_add2::IfcLabel::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[573]); }
 void Ifc4x3_add2::IfcLabel::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcLabel::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLanguageId
 const IfcParse::type_declaration& Ifc4x3_add2::IfcLanguageId::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[581]); }
+void Ifc4x3_add2::IfcLanguageId::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x3_add2::IfcLanguageId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[584]); }
 void Ifc4x3_add2::IfcLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLineIndex
 const IfcParse::type_declaration& Ifc4x3_add2::IfcLineIndex::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[610]); }
 void Ifc4x3_add2::IfcLineIndex::initialize(std::vector< int > /*[2:?]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcLineIndex::operator std::vector< int > /*[2:?]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearForceMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcLinearForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[604]); }
 void Ifc4x3_add2::IfcLinearForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcLinearForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearMomentMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcLinearMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[605]); }
 void Ifc4x3_add2::IfcLinearMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcLinearMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcLinearStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[608]); }
 void Ifc4x3_add2::IfcLinearStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcLinearStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearVelocityMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcLinearVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[609]); }
 void Ifc4x3_add2::IfcLinearVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcLinearVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLogical
 const IfcParse::type_declaration& Ifc4x3_add2::IfcLogical::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[616]); }
 void Ifc4x3_add2::IfcLogical::initialize(boost::logic::tribool v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcLogical::operator boost::logic::tribool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousFluxMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcLuminousFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[620]); }
 void Ifc4x3_add2::IfcLuminousFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcLuminousFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityDistributionMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcLuminousIntensityDistributionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[621]); }
 void Ifc4x3_add2::IfcLuminousIntensityDistributionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcLuminousIntensityDistributionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcLuminousIntensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[622]); }
 void Ifc4x3_add2::IfcLuminousIntensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcLuminousIntensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcMagneticFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[623]); }
 void Ifc4x3_add2::IfcMagneticFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcMagneticFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcMagneticFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[624]); }
 void Ifc4x3_add2::IfcMagneticFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcMagneticFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcMassDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[633]); }
 void Ifc4x3_add2::IfcMassDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcMassDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcMassFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[634]); }
 void Ifc4x3_add2::IfcMassFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcMassFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[635]); }
 void Ifc4x3_add2::IfcMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassPerLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcMassPerLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[636]); }
 void Ifc4x3_add2::IfcMassPerLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcMassPerLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfElasticityMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcModulusOfElasticityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[674]); }
 void Ifc4x3_add2::IfcModulusOfElasticityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcModulusOfElasticityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfLinearSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcModulusOfLinearSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[675]); }
 void Ifc4x3_add2::IfcModulusOfLinearSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcModulusOfLinearSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfRotationalSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcModulusOfRotationalSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[676]); }
 void Ifc4x3_add2::IfcModulusOfRotationalSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcModulusOfRotationalSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcModulusOfSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[678]); }
 void Ifc4x3_add2::IfcModulusOfSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcModulusOfSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMoistureDiffusivityMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcMoistureDiffusivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[681]); }
 void Ifc4x3_add2::IfcMoistureDiffusivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcMoistureDiffusivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMolecularWeightMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcMolecularWeightMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[682]); }
 void Ifc4x3_add2::IfcMolecularWeightMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcMolecularWeightMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMomentOfInertiaMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcMomentOfInertiaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[683]); }
 void Ifc4x3_add2::IfcMomentOfInertiaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcMomentOfInertiaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonetaryMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcMonetaryMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[684]); }
 void Ifc4x3_add2::IfcMonetaryMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcMonetaryMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonthInYearNumber
 const IfcParse::type_declaration& Ifc4x3_add2::IfcMonthInYearNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[686]); }
 void Ifc4x3_add2::IfcMonthInYearNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcMonthInYearNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNonNegativeLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcNonNegativeLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[697]); }
+void Ifc4x3_add2::IfcNonNegativeLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_add2::IfcNonNegativeLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNormalisedRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcNormalisedRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[698]); }
+void Ifc4x3_add2::IfcNormalisedRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_add2::IfcNormalisedRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNumericMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcNumericMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[699]); }
 void Ifc4x3_add2::IfcNumericMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcNumericMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPHMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcPHMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[739]); }
 void Ifc4x3_add2::IfcPHMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcPHMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcParameterValue
 const IfcParse::type_declaration& Ifc4x3_add2::IfcParameterValue::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[725]); }
 void Ifc4x3_add2::IfcParameterValue::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcParameterValue::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlanarForceMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcPlanarForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[758]); }
 void Ifc4x3_add2::IfcPlanarForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcPlanarForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[760]); }
 void Ifc4x3_add2::IfcPlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcPlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveInteger
 const IfcParse::type_declaration& Ifc4x3_add2::IfcPositiveInteger::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[776]); }
+void Ifc4x3_add2::IfcPositiveInteger::initialize(int v) { set_attribute_value(0, (v)); }
 Ifc4x3_add2::IfcPositiveInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcPositiveLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[777]); }
+void Ifc4x3_add2::IfcPositiveLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_add2::IfcPositiveLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositivePlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcPositivePlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[778]); }
+void Ifc4x3_add2::IfcPositivePlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_add2::IfcPositivePlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcPositiveRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[779]); }
+void Ifc4x3_add2::IfcPositiveRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_add2::IfcPositiveRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPowerMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[781]); }
 void Ifc4x3_add2::IfcPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPresentableText
 const IfcParse::type_declaration& Ifc4x3_add2::IfcPresentableText::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[789]); }
 void Ifc4x3_add2::IfcPresentableText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcPresentableText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPressureMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[794]); }
 void Ifc4x3_add2::IfcPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPropertySetDefinitionSet
 const IfcParse::type_declaration& Ifc4x3_add2::IfcPropertySetDefinitionSet::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[828]); }
 void Ifc4x3_add2::IfcPropertySetDefinitionSet::initialize(std::vector< ::Ifc4x3_add2::IfcPropertySetDefinition > v) { set_attribute_value(0, cast_vector<express::Base>(v)); }
+Ifc4x3_add2::IfcPropertySetDefinitionSet::operator std::vector< ::Ifc4x3_add2::IfcPropertySetDefinition >() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4x3_add2::IfcPropertySetDefinition>(es); }
 
 // Function implementations for IfcRadioActivityMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcRadioActivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[852]); }
 void Ifc4x3_add2::IfcRadioActivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcRadioActivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[869]); }
 void Ifc4x3_add2::IfcRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcReal
 const IfcParse::type_declaration& Ifc4x3_add2::IfcReal::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[872]); }
 void Ifc4x3_add2::IfcReal::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcReal::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcRotationalFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[975]); }
 void Ifc4x3_add2::IfcRotationalFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcRotationalFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalMassMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcRotationalMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[976]); }
 void Ifc4x3_add2::IfcRotationalMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcRotationalMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcRotationalStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[977]); }
 void Ifc4x3_add2::IfcRotationalStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcRotationalStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionModulusMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcSectionModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[991]); }
 void Ifc4x3_add2::IfcSectionModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcSectionModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionalAreaIntegralMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcSectionalAreaIntegralMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[986]); }
 void Ifc4x3_add2::IfcSectionalAreaIntegralMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcSectionalAreaIntegralMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcShearModulusMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcShearModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1009]); }
 void Ifc4x3_add2::IfcShearModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcShearModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSolidAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcSolidAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1035]); }
 void Ifc4x3_add2::IfcSolidAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcSolidAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerLevelMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcSoundPowerLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1038]); }
 void Ifc4x3_add2::IfcSoundPowerLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcSoundPowerLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcSoundPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1039]); }
 void Ifc4x3_add2::IfcSoundPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcSoundPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureLevelMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcSoundPressureLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1040]); }
 void Ifc4x3_add2::IfcSoundPressureLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcSoundPressureLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcSoundPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1041]); }
 void Ifc4x3_add2::IfcSoundPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcSoundPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecificHeatCapacityMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcSpecificHeatCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1057]); }
 void Ifc4x3_add2::IfcSpecificHeatCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcSpecificHeatCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularExponent
 const IfcParse::type_declaration& Ifc4x3_add2::IfcSpecularExponent::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1058]); }
 void Ifc4x3_add2::IfcSpecularExponent::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcSpecularExponent::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularRoughness
 const IfcParse::type_declaration& Ifc4x3_add2::IfcSpecularRoughness::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1060]); }
 void Ifc4x3_add2::IfcSpecularRoughness::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcSpecularRoughness::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcStrippedOptional
 const IfcParse::type_declaration& Ifc4x3_add2::IfcStrippedOptional::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1074]); }
 void Ifc4x3_add2::IfcStrippedOptional::initialize(bool v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcStrippedOptional::operator bool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureGradientMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcTemperatureGradientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1166]); }
 void Ifc4x3_add2::IfcTemperatureGradientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcTemperatureGradientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureRateOfChangeMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcTemperatureRateOfChangeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1167]); }
 void Ifc4x3_add2::IfcTemperatureRateOfChangeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcTemperatureRateOfChangeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcText
 const IfcParse::type_declaration& Ifc4x3_add2::IfcText::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1179]); }
 void Ifc4x3_add2::IfcText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextAlignment
 const IfcParse::type_declaration& Ifc4x3_add2::IfcTextAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1180]); }
 void Ifc4x3_add2::IfcTextAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcTextAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextDecoration
 const IfcParse::type_declaration& Ifc4x3_add2::IfcTextDecoration::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1181]); }
 void Ifc4x3_add2::IfcTextDecoration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcTextDecoration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextFontName
 const IfcParse::type_declaration& Ifc4x3_add2::IfcTextFontName::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1182]); }
 void Ifc4x3_add2::IfcTextFontName::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcTextFontName::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextTransformation
 const IfcParse::type_declaration& Ifc4x3_add2::IfcTextTransformation::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1191]); }
 void Ifc4x3_add2::IfcTextTransformation::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcTextTransformation::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalAdmittanceMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcThermalAdmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1199]); }
 void Ifc4x3_add2::IfcThermalAdmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcThermalAdmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalConductivityMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcThermalConductivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1200]); }
 void Ifc4x3_add2::IfcThermalConductivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcThermalConductivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalExpansionCoefficientMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcThermalExpansionCoefficientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1201]); }
 void Ifc4x3_add2::IfcThermalExpansionCoefficientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcThermalExpansionCoefficientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalResistanceMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcThermalResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1202]); }
 void Ifc4x3_add2::IfcThermalResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcThermalResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalTransmittanceMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcThermalTransmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1203]); }
 void Ifc4x3_add2::IfcThermalTransmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcThermalTransmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermodynamicTemperatureMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcThermodynamicTemperatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1204]); }
 void Ifc4x3_add2::IfcThermodynamicTemperatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcThermodynamicTemperatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTime
 const IfcParse::type_declaration& Ifc4x3_add2::IfcTime::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1206]); }
 void Ifc4x3_add2::IfcTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcTimeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1207]); }
 void Ifc4x3_add2::IfcTimeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcTimeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeStamp
 const IfcParse::type_declaration& Ifc4x3_add2::IfcTimeStamp::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1213]); }
 void Ifc4x3_add2::IfcTimeStamp::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcTimeStamp::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTorqueMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcTorqueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1217]); }
 void Ifc4x3_add2::IfcTorqueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcTorqueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcURIReference
 const IfcParse::type_declaration& Ifc4x3_add2::IfcURIReference::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1254]); }
 void Ifc4x3_add2::IfcURIReference::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcURIReference::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVaporPermeabilityMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcVaporPermeabilityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1260]); }
 void Ifc4x3_add2::IfcVaporPermeabilityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcVaporPermeabilityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumeMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcVolumeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1280]); }
 void Ifc4x3_add2::IfcVolumeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcVolumeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumetricFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcVolumetricFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1281]); }
 void Ifc4x3_add2::IfcVolumetricFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcVolumetricFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingConstantMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcWarpingConstantMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1286]); }
 void Ifc4x3_add2::IfcWarpingConstantMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcWarpingConstantMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingMomentMeasure
 const IfcParse::type_declaration& Ifc4x3_add2::IfcWarpingMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1287]); }
 void Ifc4x3_add2::IfcWarpingMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcWarpingMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWellKnownTextLiteral
 const IfcParse::type_declaration& Ifc4x3_add2::IfcWellKnownTextLiteral::Class() { return *((IfcParse::type_declaration*)IFC4X3_ADD2_types[1293]); }
 void Ifc4x3_add2::IfcWellKnownTextLiteral::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_add2::IfcWellKnownTextLiteral::operator std::string() const { return get_attribute_value(0); }
 
 
 // Function implementations for IfcActionRequest
@@ -8254,8 +8386,8 @@ int Ifc4x3_add2::IfcBSplineSurface::UDegree() const {  int v = get_attribute_val
 void Ifc4x3_add2::IfcBSplineSurface::setUDegree(const int& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
 int Ifc4x3_add2::IfcBSplineSurface::VDegree() const {  int v = get_attribute_value(1); return v; }
 void Ifc4x3_add2::IfcBSplineSurface::setVDegree(const int& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
-std::vector< std::vector< ::Ifc4x3_add2::IfcCartesianPoint > > Ifc4x3_add2::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector_vector<::Ifc4x3_add2::IfcCartesianPoint>(es); }
-void Ifc4x3_add2::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x3_add2::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
+std::vector< std::vector< ::Ifc4x3_add2::IfcCartesianPoint > > Ifc4x3_add2::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector<::Ifc4x3_add2::IfcCartesianPoint>(es); }
+void Ifc4x3_add2::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x3_add2::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
 ::Ifc4x3_add2::IfcBSplineSurfaceForm::Value Ifc4x3_add2::IfcBSplineSurface::SurfaceForm() const {  return ::Ifc4x3_add2::IfcBSplineSurfaceForm::FromString(get_attribute_value(3)); }
 void Ifc4x3_add2::IfcBSplineSurface::setSurfaceForm(const ::Ifc4x3_add2::IfcBSplineSurfaceForm::Value& v) { set_attribute_value(3, EnumerationReference(&::Ifc4x3_add2::IfcBSplineSurfaceForm::Class(), (size_t) v));if constexpr (false)unset_attribute_value(3); }
 boost::logic::tribool Ifc4x3_add2::IfcBSplineSurface::UClosed() const {  boost::logic::tribool v = get_attribute_value(4); return v; }
diff --git a/src/ifcparse/Ifc4x3_rc1.cpp b/src/ifcparse/Ifc4x3_rc1.cpp
index d7689946d4..320a624916 100644
--- a/src/ifcparse/Ifc4x3_rc1.cpp
+++ b/src/ifcparse/Ifc4x3_rc1.cpp
@@ -7193,522 +7193,652 @@ const IfcParse::select_type& Ifc4x3_rc1::IfcWarpingStiffnessSelect::Class() { re
 // Function implementations for IfcAbsorbedDoseMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcAbsorbedDoseMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[0]); }
 void Ifc4x3_rc1::IfcAbsorbedDoseMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcAbsorbedDoseMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAccelerationMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcAccelerationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1]); }
 void Ifc4x3_rc1::IfcAccelerationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcAccelerationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAmountOfSubstanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcAmountOfSubstanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[45]); }
 void Ifc4x3_rc1::IfcAmountOfSubstanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcAmountOfSubstanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAngularVelocityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcAngularVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[48]); }
 void Ifc4x3_rc1::IfcAngularVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcAngularVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcArcIndex
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcArcIndex::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[60]); }
 void Ifc4x3_rc1::IfcArcIndex::initialize(std::vector< int > /*[3:3]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcArcIndex::operator std::vector< int > /*[3:3]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcAreaDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[61]); }
 void Ifc4x3_rc1::IfcAreaDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcAreaDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcAreaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[62]); }
 void Ifc4x3_rc1::IfcAreaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcAreaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBinary
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcBinary::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[85]); }
 void Ifc4x3_rc1::IfcBinary::initialize(boost::dynamic_bitset<> v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcBinary::operator boost::dynamic_bitset<>() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoolean
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcBoolean::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[91]); }
 void Ifc4x3_rc1::IfcBoolean::initialize(bool v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcBoolean::operator bool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoxAlignment
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcBoxAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[106]); }
+void Ifc4x3_rc1::IfcBoxAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc1::IfcBoxAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCardinalPointReference
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcCardinalPointReference::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[150]); }
 void Ifc4x3_rc1::IfcCardinalPointReference::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcCardinalPointReference::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcComplexNumber
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcComplexNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[194]); }
 void Ifc4x3_rc1::IfcComplexNumber::initialize(std::vector< double > /*[1:2]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcComplexNumber::operator std::vector< double > /*[1:2]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCompoundPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcCompoundPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[202]); }
 void Ifc4x3_rc1::IfcCompoundPlaneAngleMeasure::initialize(std::vector< int > /*[3:4]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcCompoundPlaneAngleMeasure::operator std::vector< int > /*[3:4]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcContextDependentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcContextDependentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[232]); }
 void Ifc4x3_rc1::IfcContextDependentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcContextDependentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCountMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcCountMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[257]); }
 void Ifc4x3_rc1::IfcCountMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcCountMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCurvatureMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcCurvatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[275]); }
 void Ifc4x3_rc1::IfcCurvatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcCurvatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDate
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcDate::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[294]); }
 void Ifc4x3_rc1::IfcDate::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcDate::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDateTime
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcDateTime::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[295]); }
 void Ifc4x3_rc1::IfcDateTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcDateTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInMonthNumber
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcDayInMonthNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[296]); }
 void Ifc4x3_rc1::IfcDayInMonthNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcDayInMonthNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInWeekNumber
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcDayInWeekNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[297]); }
 void Ifc4x3_rc1::IfcDayInWeekNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcDayInWeekNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDescriptiveMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcDescriptiveMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[306]); }
 void Ifc4x3_rc1::IfcDescriptiveMeasure::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcDescriptiveMeasure::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDimensionCount
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcDimensionCount::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[308]); }
 void Ifc4x3_rc1::IfcDimensionCount::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcDimensionCount::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDoseEquivalentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcDoseEquivalentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[352]); }
 void Ifc4x3_rc1::IfcDoseEquivalentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcDoseEquivalentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDuration
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcDuration::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[364]); }
 void Ifc4x3_rc1::IfcDuration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcDuration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDynamicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcDynamicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[365]); }
 void Ifc4x3_rc1::IfcDynamicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcDynamicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCapacitanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcElectricCapacitanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[377]); }
 void Ifc4x3_rc1::IfcElectricCapacitanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcElectricCapacitanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricChargeMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcElectricChargeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[378]); }
 void Ifc4x3_rc1::IfcElectricChargeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcElectricChargeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricConductanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcElectricConductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[379]); }
 void Ifc4x3_rc1::IfcElectricConductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcElectricConductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCurrentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcElectricCurrentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[380]); }
 void Ifc4x3_rc1::IfcElectricCurrentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcElectricCurrentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricResistanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcElectricResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[396]); }
 void Ifc4x3_rc1::IfcElectricResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcElectricResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricVoltageMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcElectricVoltageMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[400]); }
 void Ifc4x3_rc1::IfcElectricVoltageMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcElectricVoltageMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcEnergyMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcEnergyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[415]); }
 void Ifc4x3_rc1::IfcEnergyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcEnergyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontStyle
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcFontStyle::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[496]); }
 void Ifc4x3_rc1::IfcFontStyle::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcFontStyle::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontVariant
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcFontVariant::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[497]); }
 void Ifc4x3_rc1::IfcFontVariant::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcFontVariant::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontWeight
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcFontWeight::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[498]); }
 void Ifc4x3_rc1::IfcFontWeight::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcFontWeight::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcForceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[502]); }
 void Ifc4x3_rc1::IfcForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[503]); }
 void Ifc4x3_rc1::IfcFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcGloballyUniqueId
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcGloballyUniqueId::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[524]); }
 void Ifc4x3_rc1::IfcGloballyUniqueId::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcGloballyUniqueId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcHeatFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[537]); }
 void Ifc4x3_rc1::IfcHeatFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcHeatFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatingValueMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcHeatingValueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[538]); }
 void Ifc4x3_rc1::IfcHeatingValueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcHeatingValueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIdentifier
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcIdentifier::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[542]); }
 void Ifc4x3_rc1::IfcIdentifier::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcIdentifier::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIlluminanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcIlluminanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[543]); }
 void Ifc4x3_rc1::IfcIlluminanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcIlluminanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInductanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcInductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[556]); }
 void Ifc4x3_rc1::IfcInductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcInductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInteger
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcInteger::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[557]); }
 void Ifc4x3_rc1::IfcInteger::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIntegerCountRateMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcIntegerCountRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[558]); }
 void Ifc4x3_rc1::IfcIntegerCountRateMeasure::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcIntegerCountRateMeasure::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIonConcentrationMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcIonConcentrationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[567]); }
 void Ifc4x3_rc1::IfcIonConcentrationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcIonConcentrationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIsothermalMoistureCapacityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcIsothermalMoistureCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[571]); }
 void Ifc4x3_rc1::IfcIsothermalMoistureCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcIsothermalMoistureCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcKinematicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcKinematicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[577]); }
 void Ifc4x3_rc1::IfcKinematicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcKinematicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLabel
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcLabel::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[579]); }
 void Ifc4x3_rc1::IfcLabel::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcLabel::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLanguageId
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcLanguageId::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[587]); }
+void Ifc4x3_rc1::IfcLanguageId::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc1::IfcLanguageId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[590]); }
 void Ifc4x3_rc1::IfcLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLineIndex
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcLineIndex::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[619]); }
 void Ifc4x3_rc1::IfcLineIndex::initialize(std::vector< int > /*[2:?]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcLineIndex::operator std::vector< int > /*[2:?]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearForceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcLinearForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[611]); }
 void Ifc4x3_rc1::IfcLinearForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcLinearForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearMomentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcLinearMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[612]); }
 void Ifc4x3_rc1::IfcLinearMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcLinearMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcLinearStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[617]); }
 void Ifc4x3_rc1::IfcLinearStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcLinearStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearVelocityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcLinearVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[618]); }
 void Ifc4x3_rc1::IfcLinearVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcLinearVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLogical
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcLogical::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[626]); }
 void Ifc4x3_rc1::IfcLogical::initialize(boost::logic::tribool v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcLogical::operator boost::logic::tribool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousFluxMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcLuminousFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[630]); }
 void Ifc4x3_rc1::IfcLuminousFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcLuminousFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityDistributionMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcLuminousIntensityDistributionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[631]); }
 void Ifc4x3_rc1::IfcLuminousIntensityDistributionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcLuminousIntensityDistributionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcLuminousIntensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[632]); }
 void Ifc4x3_rc1::IfcLuminousIntensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcLuminousIntensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcMagneticFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[633]); }
 void Ifc4x3_rc1::IfcMagneticFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcMagneticFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcMagneticFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[634]); }
 void Ifc4x3_rc1::IfcMagneticFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcMagneticFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcMassDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[641]); }
 void Ifc4x3_rc1::IfcMassDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcMassDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcMassFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[642]); }
 void Ifc4x3_rc1::IfcMassFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcMassFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[643]); }
 void Ifc4x3_rc1::IfcMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassPerLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcMassPerLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[644]); }
 void Ifc4x3_rc1::IfcMassPerLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcMassPerLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfElasticityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcModulusOfElasticityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[683]); }
 void Ifc4x3_rc1::IfcModulusOfElasticityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcModulusOfElasticityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfLinearSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcModulusOfLinearSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[684]); }
 void Ifc4x3_rc1::IfcModulusOfLinearSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcModulusOfLinearSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfRotationalSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcModulusOfRotationalSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[685]); }
 void Ifc4x3_rc1::IfcModulusOfRotationalSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcModulusOfRotationalSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcModulusOfSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[687]); }
 void Ifc4x3_rc1::IfcModulusOfSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcModulusOfSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMoistureDiffusivityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcMoistureDiffusivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[690]); }
 void Ifc4x3_rc1::IfcMoistureDiffusivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcMoistureDiffusivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMolecularWeightMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcMolecularWeightMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[691]); }
 void Ifc4x3_rc1::IfcMolecularWeightMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcMolecularWeightMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMomentOfInertiaMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcMomentOfInertiaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[692]); }
 void Ifc4x3_rc1::IfcMomentOfInertiaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcMomentOfInertiaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonetaryMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcMonetaryMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[693]); }
 void Ifc4x3_rc1::IfcMonetaryMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcMonetaryMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonthInYearNumber
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcMonthInYearNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[695]); }
 void Ifc4x3_rc1::IfcMonthInYearNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcMonthInYearNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNonNegativeLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcNonNegativeLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[706]); }
+void Ifc4x3_rc1::IfcNonNegativeLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc1::IfcNonNegativeLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNormalisedRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcNormalisedRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[707]); }
+void Ifc4x3_rc1::IfcNormalisedRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc1::IfcNormalisedRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNumericMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcNumericMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[709]); }
 void Ifc4x3_rc1::IfcNumericMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcNumericMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPHMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcPHMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[751]); }
 void Ifc4x3_rc1::IfcPHMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcPHMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcParameterValue
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcParameterValue::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[738]); }
 void Ifc4x3_rc1::IfcParameterValue::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcParameterValue::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlanarForceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcPlanarForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[770]); }
 void Ifc4x3_rc1::IfcPlanarForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcPlanarForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[772]); }
 void Ifc4x3_rc1::IfcPlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcPlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveInteger
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcPositiveInteger::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[788]); }
+void Ifc4x3_rc1::IfcPositiveInteger::initialize(int v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc1::IfcPositiveInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcPositiveLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[789]); }
+void Ifc4x3_rc1::IfcPositiveLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc1::IfcPositiveLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositivePlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcPositivePlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[790]); }
+void Ifc4x3_rc1::IfcPositivePlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc1::IfcPositivePlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcPositiveRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[791]); }
+void Ifc4x3_rc1::IfcPositiveRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc1::IfcPositiveRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPowerMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[793]); }
 void Ifc4x3_rc1::IfcPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPresentableText
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcPresentableText::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[801]); }
 void Ifc4x3_rc1::IfcPresentableText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcPresentableText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPressureMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[808]); }
 void Ifc4x3_rc1::IfcPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPropertySetDefinitionSet
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcPropertySetDefinitionSet::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[842]); }
 void Ifc4x3_rc1::IfcPropertySetDefinitionSet::initialize(std::vector< ::Ifc4x3_rc1::IfcPropertySetDefinition > v) { set_attribute_value(0, cast_vector<express::Base>(v)); }
+Ifc4x3_rc1::IfcPropertySetDefinitionSet::operator std::vector< ::Ifc4x3_rc1::IfcPropertySetDefinition >() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4x3_rc1::IfcPropertySetDefinition>(es); }
 
 // Function implementations for IfcRadioActivityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcRadioActivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[866]); }
 void Ifc4x3_rc1::IfcRadioActivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcRadioActivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[881]); }
 void Ifc4x3_rc1::IfcRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcReal
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcReal::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[884]); }
 void Ifc4x3_rc1::IfcReal::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcReal::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcRotationalFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[983]); }
 void Ifc4x3_rc1::IfcRotationalFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcRotationalFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalMassMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcRotationalMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[984]); }
 void Ifc4x3_rc1::IfcRotationalMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcRotationalMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcRotationalStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[985]); }
 void Ifc4x3_rc1::IfcRotationalStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcRotationalStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionModulusMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcSectionModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[998]); }
 void Ifc4x3_rc1::IfcSectionModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcSectionModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionalAreaIntegralMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcSectionalAreaIntegralMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[993]); }
 void Ifc4x3_rc1::IfcSectionalAreaIntegralMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcSectionalAreaIntegralMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcShearModulusMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcShearModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1013]); }
 void Ifc4x3_rc1::IfcShearModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcShearModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSolidAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcSolidAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1040]); }
 void Ifc4x3_rc1::IfcSolidAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcSolidAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerLevelMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcSoundPowerLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1044]); }
 void Ifc4x3_rc1::IfcSoundPowerLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcSoundPowerLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcSoundPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1045]); }
 void Ifc4x3_rc1::IfcSoundPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcSoundPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureLevelMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcSoundPressureLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1046]); }
 void Ifc4x3_rc1::IfcSoundPressureLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcSoundPressureLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcSoundPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1047]); }
 void Ifc4x3_rc1::IfcSoundPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcSoundPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecificHeatCapacityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcSpecificHeatCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1063]); }
 void Ifc4x3_rc1::IfcSpecificHeatCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcSpecificHeatCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularExponent
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcSpecularExponent::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1064]); }
 void Ifc4x3_rc1::IfcSpecularExponent::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcSpecularExponent::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularRoughness
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcSpecularRoughness::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1066]); }
 void Ifc4x3_rc1::IfcSpecularRoughness::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcSpecularRoughness::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureGradientMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcTemperatureGradientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1171]); }
 void Ifc4x3_rc1::IfcTemperatureGradientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcTemperatureGradientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureRateOfChangeMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcTemperatureRateOfChangeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1172]); }
 void Ifc4x3_rc1::IfcTemperatureRateOfChangeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcTemperatureRateOfChangeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcText
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcText::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1184]); }
 void Ifc4x3_rc1::IfcText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextAlignment
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcTextAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1185]); }
 void Ifc4x3_rc1::IfcTextAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcTextAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextDecoration
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcTextDecoration::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1186]); }
 void Ifc4x3_rc1::IfcTextDecoration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcTextDecoration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextFontName
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcTextFontName::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1187]); }
 void Ifc4x3_rc1::IfcTextFontName::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcTextFontName::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextTransformation
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcTextTransformation::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1196]); }
 void Ifc4x3_rc1::IfcTextTransformation::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcTextTransformation::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalAdmittanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcThermalAdmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1202]); }
 void Ifc4x3_rc1::IfcThermalAdmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcThermalAdmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalConductivityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcThermalConductivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1203]); }
 void Ifc4x3_rc1::IfcThermalConductivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcThermalConductivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalExpansionCoefficientMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcThermalExpansionCoefficientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1204]); }
 void Ifc4x3_rc1::IfcThermalExpansionCoefficientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcThermalExpansionCoefficientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalResistanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcThermalResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1205]); }
 void Ifc4x3_rc1::IfcThermalResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcThermalResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalTransmittanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcThermalTransmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1206]); }
 void Ifc4x3_rc1::IfcThermalTransmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcThermalTransmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermodynamicTemperatureMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcThermodynamicTemperatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1207]); }
 void Ifc4x3_rc1::IfcThermodynamicTemperatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcThermodynamicTemperatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTime
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcTime::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1208]); }
 void Ifc4x3_rc1::IfcTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcTimeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1209]); }
 void Ifc4x3_rc1::IfcTimeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcTimeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeStamp
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcTimeStamp::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1215]); }
 void Ifc4x3_rc1::IfcTimeStamp::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcTimeStamp::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTorqueMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcTorqueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1219]); }
 void Ifc4x3_rc1::IfcTorqueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcTorqueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcURIReference
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcURIReference::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1258]); }
 void Ifc4x3_rc1::IfcURIReference::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcURIReference::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVaporPermeabilityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcVaporPermeabilityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1264]); }
 void Ifc4x3_rc1::IfcVaporPermeabilityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcVaporPermeabilityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumeMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcVolumeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1281]); }
 void Ifc4x3_rc1::IfcVolumeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcVolumeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumetricFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcVolumetricFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1282]); }
 void Ifc4x3_rc1::IfcVolumetricFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcVolumetricFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingConstantMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcWarpingConstantMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1288]); }
 void Ifc4x3_rc1::IfcWarpingConstantMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcWarpingConstantMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingMomentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc1::IfcWarpingMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC1_types[1289]); }
 void Ifc4x3_rc1::IfcWarpingMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc1::IfcWarpingMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 
 // Function implementations for IfcActionRequest
@@ -8287,8 +8417,8 @@ int Ifc4x3_rc1::IfcBSplineSurface::UDegree() const {  int v = get_attribute_valu
 void Ifc4x3_rc1::IfcBSplineSurface::setUDegree(const int& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
 int Ifc4x3_rc1::IfcBSplineSurface::VDegree() const {  int v = get_attribute_value(1); return v; }
 void Ifc4x3_rc1::IfcBSplineSurface::setVDegree(const int& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
-std::vector< std::vector< ::Ifc4x3_rc1::IfcCartesianPoint > > Ifc4x3_rc1::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector_vector<::Ifc4x3_rc1::IfcCartesianPoint>(es); }
-void Ifc4x3_rc1::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x3_rc1::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
+std::vector< std::vector< ::Ifc4x3_rc1::IfcCartesianPoint > > Ifc4x3_rc1::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector<::Ifc4x3_rc1::IfcCartesianPoint>(es); }
+void Ifc4x3_rc1::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x3_rc1::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
 ::Ifc4x3_rc1::IfcBSplineSurfaceForm::Value Ifc4x3_rc1::IfcBSplineSurface::SurfaceForm() const {  return ::Ifc4x3_rc1::IfcBSplineSurfaceForm::FromString(get_attribute_value(3)); }
 void Ifc4x3_rc1::IfcBSplineSurface::setSurfaceForm(const ::Ifc4x3_rc1::IfcBSplineSurfaceForm::Value& v) { set_attribute_value(3, EnumerationReference(&::Ifc4x3_rc1::IfcBSplineSurfaceForm::Class(), (size_t) v));if constexpr (false)unset_attribute_value(3); }
 boost::logic::tribool Ifc4x3_rc1::IfcBSplineSurface::UClosed() const {  boost::logic::tribool v = get_attribute_value(4); return v; }
diff --git a/src/ifcparse/Ifc4x3_rc2.cpp b/src/ifcparse/Ifc4x3_rc2.cpp
index cd57ca13ac..e1d3b43de6 100644
--- a/src/ifcparse/Ifc4x3_rc2.cpp
+++ b/src/ifcparse/Ifc4x3_rc2.cpp
@@ -7282,522 +7282,652 @@ const IfcParse::select_type& Ifc4x3_rc2::IfcWarpingStiffnessSelect::Class() { re
 // Function implementations for IfcAbsorbedDoseMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcAbsorbedDoseMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[0]); }
 void Ifc4x3_rc2::IfcAbsorbedDoseMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcAbsorbedDoseMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAccelerationMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcAccelerationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1]); }
 void Ifc4x3_rc2::IfcAccelerationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcAccelerationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAmountOfSubstanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcAmountOfSubstanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[46]); }
 void Ifc4x3_rc2::IfcAmountOfSubstanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcAmountOfSubstanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAngularVelocityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcAngularVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[49]); }
 void Ifc4x3_rc2::IfcAngularVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcAngularVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcArcIndex
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcArcIndex::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[61]); }
 void Ifc4x3_rc2::IfcArcIndex::initialize(std::vector< int > /*[3:3]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcArcIndex::operator std::vector< int > /*[3:3]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcAreaDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[62]); }
 void Ifc4x3_rc2::IfcAreaDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcAreaDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcAreaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[63]); }
 void Ifc4x3_rc2::IfcAreaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcAreaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBinary
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcBinary::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[87]); }
 void Ifc4x3_rc2::IfcBinary::initialize(boost::dynamic_bitset<> v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcBinary::operator boost::dynamic_bitset<>() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoolean
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcBoolean::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[94]); }
 void Ifc4x3_rc2::IfcBoolean::initialize(bool v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcBoolean::operator bool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoxAlignment
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcBoxAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[109]); }
+void Ifc4x3_rc2::IfcBoxAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc2::IfcBoxAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCardinalPointReference
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcCardinalPointReference::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[153]); }
 void Ifc4x3_rc2::IfcCardinalPointReference::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcCardinalPointReference::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcComplexNumber
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcComplexNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[198]); }
 void Ifc4x3_rc2::IfcComplexNumber::initialize(std::vector< double > /*[1:2]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcComplexNumber::operator std::vector< double > /*[1:2]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCompoundPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcCompoundPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[206]); }
 void Ifc4x3_rc2::IfcCompoundPlaneAngleMeasure::initialize(std::vector< int > /*[3:4]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcCompoundPlaneAngleMeasure::operator std::vector< int > /*[3:4]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcContextDependentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcContextDependentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[236]); }
 void Ifc4x3_rc2::IfcContextDependentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcContextDependentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCountMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcCountMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[261]); }
 void Ifc4x3_rc2::IfcCountMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcCountMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCurvatureMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcCurvatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[279]); }
 void Ifc4x3_rc2::IfcCurvatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcCurvatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDate
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcDate::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[300]); }
 void Ifc4x3_rc2::IfcDate::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcDate::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDateTime
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcDateTime::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[301]); }
 void Ifc4x3_rc2::IfcDateTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcDateTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInMonthNumber
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcDayInMonthNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[302]); }
 void Ifc4x3_rc2::IfcDayInMonthNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcDayInMonthNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInWeekNumber
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcDayInWeekNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[303]); }
 void Ifc4x3_rc2::IfcDayInWeekNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcDayInWeekNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDescriptiveMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcDescriptiveMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[312]); }
 void Ifc4x3_rc2::IfcDescriptiveMeasure::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcDescriptiveMeasure::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDimensionCount
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcDimensionCount::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[314]); }
 void Ifc4x3_rc2::IfcDimensionCount::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcDimensionCount::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDoseEquivalentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcDoseEquivalentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[357]); }
 void Ifc4x3_rc2::IfcDoseEquivalentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcDoseEquivalentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDuration
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcDuration::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[369]); }
 void Ifc4x3_rc2::IfcDuration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcDuration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDynamicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcDynamicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[370]); }
 void Ifc4x3_rc2::IfcDynamicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcDynamicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCapacitanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcElectricCapacitanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[382]); }
 void Ifc4x3_rc2::IfcElectricCapacitanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcElectricCapacitanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricChargeMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcElectricChargeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[383]); }
 void Ifc4x3_rc2::IfcElectricChargeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcElectricChargeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricConductanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcElectricConductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[384]); }
 void Ifc4x3_rc2::IfcElectricConductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcElectricConductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCurrentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcElectricCurrentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[385]); }
 void Ifc4x3_rc2::IfcElectricCurrentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcElectricCurrentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricResistanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcElectricResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[401]); }
 void Ifc4x3_rc2::IfcElectricResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcElectricResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricVoltageMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcElectricVoltageMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[405]); }
 void Ifc4x3_rc2::IfcElectricVoltageMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcElectricVoltageMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcEnergyMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcEnergyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[420]); }
 void Ifc4x3_rc2::IfcEnergyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcEnergyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontStyle
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcFontStyle::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[501]); }
 void Ifc4x3_rc2::IfcFontStyle::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcFontStyle::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontVariant
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcFontVariant::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[502]); }
 void Ifc4x3_rc2::IfcFontVariant::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcFontVariant::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontWeight
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcFontWeight::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[503]); }
 void Ifc4x3_rc2::IfcFontWeight::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcFontWeight::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcForceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[507]); }
 void Ifc4x3_rc2::IfcForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[508]); }
 void Ifc4x3_rc2::IfcFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcGloballyUniqueId
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcGloballyUniqueId::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[529]); }
 void Ifc4x3_rc2::IfcGloballyUniqueId::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcGloballyUniqueId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcHeatFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[543]); }
 void Ifc4x3_rc2::IfcHeatFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcHeatFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatingValueMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcHeatingValueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[544]); }
 void Ifc4x3_rc2::IfcHeatingValueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcHeatingValueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIdentifier
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcIdentifier::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[548]); }
 void Ifc4x3_rc2::IfcIdentifier::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcIdentifier::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIlluminanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcIlluminanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[549]); }
 void Ifc4x3_rc2::IfcIlluminanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcIlluminanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInductanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcInductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[562]); }
 void Ifc4x3_rc2::IfcInductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcInductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInteger
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcInteger::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[563]); }
 void Ifc4x3_rc2::IfcInteger::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIntegerCountRateMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcIntegerCountRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[564]); }
 void Ifc4x3_rc2::IfcIntegerCountRateMeasure::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcIntegerCountRateMeasure::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIonConcentrationMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcIonConcentrationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[573]); }
 void Ifc4x3_rc2::IfcIonConcentrationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcIonConcentrationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIsothermalMoistureCapacityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcIsothermalMoistureCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[577]); }
 void Ifc4x3_rc2::IfcIsothermalMoistureCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcIsothermalMoistureCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcKinematicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcKinematicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[583]); }
 void Ifc4x3_rc2::IfcKinematicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcKinematicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLabel
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcLabel::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[585]); }
 void Ifc4x3_rc2::IfcLabel::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcLabel::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLanguageId
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcLanguageId::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[593]); }
+void Ifc4x3_rc2::IfcLanguageId::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc2::IfcLanguageId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[596]); }
 void Ifc4x3_rc2::IfcLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLineIndex
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcLineIndex::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[626]); }
 void Ifc4x3_rc2::IfcLineIndex::initialize(std::vector< int > /*[2:?]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcLineIndex::operator std::vector< int > /*[2:?]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearForceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcLinearForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[618]); }
 void Ifc4x3_rc2::IfcLinearForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcLinearForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearMomentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcLinearMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[619]); }
 void Ifc4x3_rc2::IfcLinearMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcLinearMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcLinearStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[624]); }
 void Ifc4x3_rc2::IfcLinearStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcLinearStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearVelocityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcLinearVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[625]); }
 void Ifc4x3_rc2::IfcLinearVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcLinearVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLogical
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcLogical::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[633]); }
 void Ifc4x3_rc2::IfcLogical::initialize(boost::logic::tribool v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcLogical::operator boost::logic::tribool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousFluxMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcLuminousFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[637]); }
 void Ifc4x3_rc2::IfcLuminousFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcLuminousFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityDistributionMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcLuminousIntensityDistributionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[638]); }
 void Ifc4x3_rc2::IfcLuminousIntensityDistributionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcLuminousIntensityDistributionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcLuminousIntensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[639]); }
 void Ifc4x3_rc2::IfcLuminousIntensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcLuminousIntensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcMagneticFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[640]); }
 void Ifc4x3_rc2::IfcMagneticFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcMagneticFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcMagneticFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[641]); }
 void Ifc4x3_rc2::IfcMagneticFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcMagneticFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcMassDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[648]); }
 void Ifc4x3_rc2::IfcMassDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcMassDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcMassFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[649]); }
 void Ifc4x3_rc2::IfcMassFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcMassFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[650]); }
 void Ifc4x3_rc2::IfcMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassPerLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcMassPerLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[651]); }
 void Ifc4x3_rc2::IfcMassPerLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcMassPerLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfElasticityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcModulusOfElasticityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[690]); }
 void Ifc4x3_rc2::IfcModulusOfElasticityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcModulusOfElasticityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfLinearSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcModulusOfLinearSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[691]); }
 void Ifc4x3_rc2::IfcModulusOfLinearSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcModulusOfLinearSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfRotationalSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcModulusOfRotationalSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[692]); }
 void Ifc4x3_rc2::IfcModulusOfRotationalSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcModulusOfRotationalSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcModulusOfSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[694]); }
 void Ifc4x3_rc2::IfcModulusOfSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcModulusOfSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMoistureDiffusivityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcMoistureDiffusivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[697]); }
 void Ifc4x3_rc2::IfcMoistureDiffusivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcMoistureDiffusivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMolecularWeightMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcMolecularWeightMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[698]); }
 void Ifc4x3_rc2::IfcMolecularWeightMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcMolecularWeightMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMomentOfInertiaMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcMomentOfInertiaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[699]); }
 void Ifc4x3_rc2::IfcMomentOfInertiaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcMomentOfInertiaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonetaryMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcMonetaryMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[700]); }
 void Ifc4x3_rc2::IfcMonetaryMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcMonetaryMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonthInYearNumber
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcMonthInYearNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[702]); }
 void Ifc4x3_rc2::IfcMonthInYearNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcMonthInYearNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNonNegativeLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcNonNegativeLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[713]); }
+void Ifc4x3_rc2::IfcNonNegativeLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc2::IfcNonNegativeLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNormalisedRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcNormalisedRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[714]); }
+void Ifc4x3_rc2::IfcNormalisedRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc2::IfcNormalisedRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNumericMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcNumericMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[716]); }
 void Ifc4x3_rc2::IfcNumericMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcNumericMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPHMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcPHMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[757]); }
 void Ifc4x3_rc2::IfcPHMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcPHMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcParameterValue
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcParameterValue::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[744]); }
 void Ifc4x3_rc2::IfcParameterValue::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcParameterValue::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlanarForceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcPlanarForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[776]); }
 void Ifc4x3_rc2::IfcPlanarForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcPlanarForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[778]); }
 void Ifc4x3_rc2::IfcPlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcPlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveInteger
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcPositiveInteger::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[795]); }
+void Ifc4x3_rc2::IfcPositiveInteger::initialize(int v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc2::IfcPositiveInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcPositiveLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[796]); }
+void Ifc4x3_rc2::IfcPositiveLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc2::IfcPositiveLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositivePlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcPositivePlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[797]); }
+void Ifc4x3_rc2::IfcPositivePlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc2::IfcPositivePlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcPositiveRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[798]); }
+void Ifc4x3_rc2::IfcPositiveRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc2::IfcPositiveRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPowerMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[800]); }
 void Ifc4x3_rc2::IfcPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPresentableText
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcPresentableText::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[808]); }
 void Ifc4x3_rc2::IfcPresentableText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcPresentableText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPressureMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[815]); }
 void Ifc4x3_rc2::IfcPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPropertySetDefinitionSet
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcPropertySetDefinitionSet::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[849]); }
 void Ifc4x3_rc2::IfcPropertySetDefinitionSet::initialize(std::vector< ::Ifc4x3_rc2::IfcPropertySetDefinition > v) { set_attribute_value(0, cast_vector<express::Base>(v)); }
+Ifc4x3_rc2::IfcPropertySetDefinitionSet::operator std::vector< ::Ifc4x3_rc2::IfcPropertySetDefinition >() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4x3_rc2::IfcPropertySetDefinition>(es); }
 
 // Function implementations for IfcRadioActivityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcRadioActivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[873]); }
 void Ifc4x3_rc2::IfcRadioActivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcRadioActivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[888]); }
 void Ifc4x3_rc2::IfcRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcReal
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcReal::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[891]); }
 void Ifc4x3_rc2::IfcReal::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcReal::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcRotationalFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[990]); }
 void Ifc4x3_rc2::IfcRotationalFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcRotationalFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalMassMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcRotationalMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[991]); }
 void Ifc4x3_rc2::IfcRotationalMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcRotationalMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcRotationalStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[992]); }
 void Ifc4x3_rc2::IfcRotationalStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcRotationalStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionModulusMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcSectionModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1005]); }
 void Ifc4x3_rc2::IfcSectionModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcSectionModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionalAreaIntegralMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcSectionalAreaIntegralMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1000]); }
 void Ifc4x3_rc2::IfcSectionalAreaIntegralMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcSectionalAreaIntegralMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcShearModulusMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcShearModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1023]); }
 void Ifc4x3_rc2::IfcShearModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcShearModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSolidAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcSolidAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1050]); }
 void Ifc4x3_rc2::IfcSolidAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcSolidAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerLevelMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcSoundPowerLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1054]); }
 void Ifc4x3_rc2::IfcSoundPowerLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcSoundPowerLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcSoundPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1055]); }
 void Ifc4x3_rc2::IfcSoundPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcSoundPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureLevelMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcSoundPressureLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1056]); }
 void Ifc4x3_rc2::IfcSoundPressureLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcSoundPressureLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcSoundPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1057]); }
 void Ifc4x3_rc2::IfcSoundPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcSoundPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecificHeatCapacityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcSpecificHeatCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1073]); }
 void Ifc4x3_rc2::IfcSpecificHeatCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcSpecificHeatCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularExponent
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcSpecularExponent::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1074]); }
 void Ifc4x3_rc2::IfcSpecularExponent::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcSpecularExponent::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularRoughness
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcSpecularRoughness::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1076]); }
 void Ifc4x3_rc2::IfcSpecularRoughness::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcSpecularRoughness::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureGradientMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcTemperatureGradientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1181]); }
 void Ifc4x3_rc2::IfcTemperatureGradientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcTemperatureGradientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureRateOfChangeMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcTemperatureRateOfChangeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1182]); }
 void Ifc4x3_rc2::IfcTemperatureRateOfChangeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcTemperatureRateOfChangeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcText
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcText::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1194]); }
 void Ifc4x3_rc2::IfcText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextAlignment
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcTextAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1195]); }
 void Ifc4x3_rc2::IfcTextAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcTextAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextDecoration
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcTextDecoration::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1196]); }
 void Ifc4x3_rc2::IfcTextDecoration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcTextDecoration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextFontName
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcTextFontName::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1197]); }
 void Ifc4x3_rc2::IfcTextFontName::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcTextFontName::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextTransformation
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcTextTransformation::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1206]); }
 void Ifc4x3_rc2::IfcTextTransformation::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcTextTransformation::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalAdmittanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcThermalAdmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1212]); }
 void Ifc4x3_rc2::IfcThermalAdmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcThermalAdmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalConductivityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcThermalConductivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1213]); }
 void Ifc4x3_rc2::IfcThermalConductivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcThermalConductivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalExpansionCoefficientMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcThermalExpansionCoefficientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1214]); }
 void Ifc4x3_rc2::IfcThermalExpansionCoefficientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcThermalExpansionCoefficientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalResistanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcThermalResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1215]); }
 void Ifc4x3_rc2::IfcThermalResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcThermalResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalTransmittanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcThermalTransmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1216]); }
 void Ifc4x3_rc2::IfcThermalTransmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcThermalTransmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermodynamicTemperatureMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcThermodynamicTemperatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1217]); }
 void Ifc4x3_rc2::IfcThermodynamicTemperatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcThermodynamicTemperatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTime
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcTime::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1218]); }
 void Ifc4x3_rc2::IfcTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcTimeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1219]); }
 void Ifc4x3_rc2::IfcTimeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcTimeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeStamp
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcTimeStamp::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1225]); }
 void Ifc4x3_rc2::IfcTimeStamp::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcTimeStamp::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTorqueMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcTorqueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1229]); }
 void Ifc4x3_rc2::IfcTorqueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcTorqueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcURIReference
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcURIReference::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1268]); }
 void Ifc4x3_rc2::IfcURIReference::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcURIReference::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVaporPermeabilityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcVaporPermeabilityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1274]); }
 void Ifc4x3_rc2::IfcVaporPermeabilityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcVaporPermeabilityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumeMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcVolumeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1291]); }
 void Ifc4x3_rc2::IfcVolumeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcVolumeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumetricFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcVolumetricFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1292]); }
 void Ifc4x3_rc2::IfcVolumetricFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcVolumetricFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingConstantMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcWarpingConstantMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1298]); }
 void Ifc4x3_rc2::IfcWarpingConstantMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcWarpingConstantMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingMomentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc2::IfcWarpingMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC2_types[1299]); }
 void Ifc4x3_rc2::IfcWarpingMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc2::IfcWarpingMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 
 // Function implementations for IfcActionRequest
@@ -8371,8 +8501,8 @@ int Ifc4x3_rc2::IfcBSplineSurface::UDegree() const {  int v = get_attribute_valu
 void Ifc4x3_rc2::IfcBSplineSurface::setUDegree(const int& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
 int Ifc4x3_rc2::IfcBSplineSurface::VDegree() const {  int v = get_attribute_value(1); return v; }
 void Ifc4x3_rc2::IfcBSplineSurface::setVDegree(const int& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
-std::vector< std::vector< ::Ifc4x3_rc2::IfcCartesianPoint > > Ifc4x3_rc2::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector_vector<::Ifc4x3_rc2::IfcCartesianPoint>(es); }
-void Ifc4x3_rc2::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x3_rc2::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
+std::vector< std::vector< ::Ifc4x3_rc2::IfcCartesianPoint > > Ifc4x3_rc2::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector<::Ifc4x3_rc2::IfcCartesianPoint>(es); }
+void Ifc4x3_rc2::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x3_rc2::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
 ::Ifc4x3_rc2::IfcBSplineSurfaceForm::Value Ifc4x3_rc2::IfcBSplineSurface::SurfaceForm() const {  return ::Ifc4x3_rc2::IfcBSplineSurfaceForm::FromString(get_attribute_value(3)); }
 void Ifc4x3_rc2::IfcBSplineSurface::setSurfaceForm(const ::Ifc4x3_rc2::IfcBSplineSurfaceForm::Value& v) { set_attribute_value(3, EnumerationReference(&::Ifc4x3_rc2::IfcBSplineSurfaceForm::Class(), (size_t) v));if constexpr (false)unset_attribute_value(3); }
 boost::logic::tribool Ifc4x3_rc2::IfcBSplineSurface::UClosed() const {  boost::logic::tribool v = get_attribute_value(4); return v; }
diff --git a/src/ifcparse/Ifc4x3_rc3.cpp b/src/ifcparse/Ifc4x3_rc3.cpp
index e4f8cde76e..734c8f4800 100644
--- a/src/ifcparse/Ifc4x3_rc3.cpp
+++ b/src/ifcparse/Ifc4x3_rc3.cpp
@@ -7305,522 +7305,652 @@ const IfcParse::select_type& Ifc4x3_rc3::IfcWarpingStiffnessSelect::Class() { re
 // Function implementations for IfcAbsorbedDoseMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcAbsorbedDoseMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[0]); }
 void Ifc4x3_rc3::IfcAbsorbedDoseMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcAbsorbedDoseMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAccelerationMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcAccelerationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1]); }
 void Ifc4x3_rc3::IfcAccelerationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcAccelerationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAmountOfSubstanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcAmountOfSubstanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[42]); }
 void Ifc4x3_rc3::IfcAmountOfSubstanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcAmountOfSubstanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAngularVelocityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcAngularVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[45]); }
 void Ifc4x3_rc3::IfcAngularVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcAngularVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcArcIndex
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcArcIndex::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[57]); }
 void Ifc4x3_rc3::IfcArcIndex::initialize(std::vector< int > /*[3:3]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcArcIndex::operator std::vector< int > /*[3:3]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcAreaDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[58]); }
 void Ifc4x3_rc3::IfcAreaDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcAreaDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcAreaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[59]); }
 void Ifc4x3_rc3::IfcAreaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcAreaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBinary
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcBinary::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[82]); }
 void Ifc4x3_rc3::IfcBinary::initialize(boost::dynamic_bitset<> v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcBinary::operator boost::dynamic_bitset<>() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoolean
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcBoolean::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[88]); }
 void Ifc4x3_rc3::IfcBoolean::initialize(bool v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcBoolean::operator bool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoxAlignment
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcBoxAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[103]); }
+void Ifc4x3_rc3::IfcBoxAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc3::IfcBoxAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCardinalPointReference
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcCardinalPointReference::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[146]); }
 void Ifc4x3_rc3::IfcCardinalPointReference::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcCardinalPointReference::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcComplexNumber
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcComplexNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[190]); }
 void Ifc4x3_rc3::IfcComplexNumber::initialize(std::vector< double > /*[1:2]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcComplexNumber::operator std::vector< double > /*[1:2]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCompoundPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcCompoundPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[198]); }
 void Ifc4x3_rc3::IfcCompoundPlaneAngleMeasure::initialize(std::vector< int > /*[3:4]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcCompoundPlaneAngleMeasure::operator std::vector< int > /*[3:4]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcContextDependentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcContextDependentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[228]); }
 void Ifc4x3_rc3::IfcContextDependentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcContextDependentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCountMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcCountMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[254]); }
 void Ifc4x3_rc3::IfcCountMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcCountMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCurvatureMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcCurvatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[272]); }
 void Ifc4x3_rc3::IfcCurvatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcCurvatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDate
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcDate::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[292]); }
 void Ifc4x3_rc3::IfcDate::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcDate::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDateTime
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcDateTime::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[293]); }
 void Ifc4x3_rc3::IfcDateTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcDateTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInMonthNumber
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcDayInMonthNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[294]); }
 void Ifc4x3_rc3::IfcDayInMonthNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcDayInMonthNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInWeekNumber
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcDayInWeekNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[295]); }
 void Ifc4x3_rc3::IfcDayInWeekNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcDayInWeekNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDescriptiveMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcDescriptiveMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[304]); }
 void Ifc4x3_rc3::IfcDescriptiveMeasure::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcDescriptiveMeasure::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDimensionCount
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcDimensionCount::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[306]); }
 void Ifc4x3_rc3::IfcDimensionCount::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcDimensionCount::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDoseEquivalentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcDoseEquivalentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[350]); }
 void Ifc4x3_rc3::IfcDoseEquivalentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcDoseEquivalentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDuration
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcDuration::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[362]); }
 void Ifc4x3_rc3::IfcDuration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcDuration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDynamicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcDynamicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[363]); }
 void Ifc4x3_rc3::IfcDynamicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcDynamicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCapacitanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcElectricCapacitanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[375]); }
 void Ifc4x3_rc3::IfcElectricCapacitanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcElectricCapacitanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricChargeMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcElectricChargeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[376]); }
 void Ifc4x3_rc3::IfcElectricChargeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcElectricChargeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricConductanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcElectricConductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[377]); }
 void Ifc4x3_rc3::IfcElectricConductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcElectricConductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCurrentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcElectricCurrentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[378]); }
 void Ifc4x3_rc3::IfcElectricCurrentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcElectricCurrentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricResistanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcElectricResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[394]); }
 void Ifc4x3_rc3::IfcElectricResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcElectricResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricVoltageMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcElectricVoltageMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[398]); }
 void Ifc4x3_rc3::IfcElectricVoltageMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcElectricVoltageMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcEnergyMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcEnergyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[413]); }
 void Ifc4x3_rc3::IfcEnergyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcEnergyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontStyle
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcFontStyle::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[494]); }
 void Ifc4x3_rc3::IfcFontStyle::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcFontStyle::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontVariant
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcFontVariant::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[495]); }
 void Ifc4x3_rc3::IfcFontVariant::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcFontVariant::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontWeight
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcFontWeight::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[496]); }
 void Ifc4x3_rc3::IfcFontWeight::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcFontWeight::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcForceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[500]); }
 void Ifc4x3_rc3::IfcForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[501]); }
 void Ifc4x3_rc3::IfcFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcGloballyUniqueId
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcGloballyUniqueId::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[522]); }
 void Ifc4x3_rc3::IfcGloballyUniqueId::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcGloballyUniqueId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcHeatFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[536]); }
 void Ifc4x3_rc3::IfcHeatFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcHeatFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatingValueMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcHeatingValueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[537]); }
 void Ifc4x3_rc3::IfcHeatingValueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcHeatingValueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIdentifier
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcIdentifier::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[541]); }
 void Ifc4x3_rc3::IfcIdentifier::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcIdentifier::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIlluminanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcIlluminanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[542]); }
 void Ifc4x3_rc3::IfcIlluminanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcIlluminanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInductanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcInductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[555]); }
 void Ifc4x3_rc3::IfcInductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcInductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInteger
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcInteger::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[556]); }
 void Ifc4x3_rc3::IfcInteger::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIntegerCountRateMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcIntegerCountRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[557]); }
 void Ifc4x3_rc3::IfcIntegerCountRateMeasure::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcIntegerCountRateMeasure::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIonConcentrationMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcIonConcentrationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[566]); }
 void Ifc4x3_rc3::IfcIonConcentrationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcIonConcentrationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIsothermalMoistureCapacityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcIsothermalMoistureCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[570]); }
 void Ifc4x3_rc3::IfcIsothermalMoistureCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcIsothermalMoistureCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcKinematicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcKinematicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[576]); }
 void Ifc4x3_rc3::IfcKinematicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcKinematicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLabel
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcLabel::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[578]); }
 void Ifc4x3_rc3::IfcLabel::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcLabel::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLanguageId
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcLanguageId::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[586]); }
+void Ifc4x3_rc3::IfcLanguageId::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc3::IfcLanguageId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[589]); }
 void Ifc4x3_rc3::IfcLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLineIndex
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcLineIndex::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[615]); }
 void Ifc4x3_rc3::IfcLineIndex::initialize(std::vector< int > /*[2:?]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcLineIndex::operator std::vector< int > /*[2:?]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearForceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcLinearForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[609]); }
 void Ifc4x3_rc3::IfcLinearForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcLinearForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearMomentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcLinearMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[610]); }
 void Ifc4x3_rc3::IfcLinearMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcLinearMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcLinearStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[613]); }
 void Ifc4x3_rc3::IfcLinearStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcLinearStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearVelocityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcLinearVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[614]); }
 void Ifc4x3_rc3::IfcLinearVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcLinearVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLogical
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcLogical::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[621]); }
 void Ifc4x3_rc3::IfcLogical::initialize(boost::logic::tribool v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcLogical::operator boost::logic::tribool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousFluxMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcLuminousFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[625]); }
 void Ifc4x3_rc3::IfcLuminousFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcLuminousFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityDistributionMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcLuminousIntensityDistributionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[626]); }
 void Ifc4x3_rc3::IfcLuminousIntensityDistributionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcLuminousIntensityDistributionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcLuminousIntensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[627]); }
 void Ifc4x3_rc3::IfcLuminousIntensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcLuminousIntensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcMagneticFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[628]); }
 void Ifc4x3_rc3::IfcMagneticFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcMagneticFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcMagneticFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[629]); }
 void Ifc4x3_rc3::IfcMagneticFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcMagneticFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcMassDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[636]); }
 void Ifc4x3_rc3::IfcMassDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcMassDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcMassFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[637]); }
 void Ifc4x3_rc3::IfcMassFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcMassFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[638]); }
 void Ifc4x3_rc3::IfcMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassPerLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcMassPerLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[639]); }
 void Ifc4x3_rc3::IfcMassPerLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcMassPerLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfElasticityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcModulusOfElasticityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[678]); }
 void Ifc4x3_rc3::IfcModulusOfElasticityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcModulusOfElasticityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfLinearSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcModulusOfLinearSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[679]); }
 void Ifc4x3_rc3::IfcModulusOfLinearSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcModulusOfLinearSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfRotationalSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcModulusOfRotationalSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[680]); }
 void Ifc4x3_rc3::IfcModulusOfRotationalSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcModulusOfRotationalSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcModulusOfSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[682]); }
 void Ifc4x3_rc3::IfcModulusOfSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcModulusOfSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMoistureDiffusivityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcMoistureDiffusivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[685]); }
 void Ifc4x3_rc3::IfcMoistureDiffusivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcMoistureDiffusivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMolecularWeightMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcMolecularWeightMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[686]); }
 void Ifc4x3_rc3::IfcMolecularWeightMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcMolecularWeightMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMomentOfInertiaMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcMomentOfInertiaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[687]); }
 void Ifc4x3_rc3::IfcMomentOfInertiaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcMomentOfInertiaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonetaryMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcMonetaryMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[688]); }
 void Ifc4x3_rc3::IfcMonetaryMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcMonetaryMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonthInYearNumber
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcMonthInYearNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[690]); }
 void Ifc4x3_rc3::IfcMonthInYearNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcMonthInYearNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNonNegativeLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcNonNegativeLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[701]); }
+void Ifc4x3_rc3::IfcNonNegativeLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc3::IfcNonNegativeLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNormalisedRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcNormalisedRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[702]); }
+void Ifc4x3_rc3::IfcNormalisedRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc3::IfcNormalisedRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNumericMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcNumericMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[703]); }
 void Ifc4x3_rc3::IfcNumericMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcNumericMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPHMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcPHMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[745]); }
 void Ifc4x3_rc3::IfcPHMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcPHMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcParameterValue
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcParameterValue::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[731]); }
 void Ifc4x3_rc3::IfcParameterValue::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcParameterValue::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlanarForceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcPlanarForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[764]); }
 void Ifc4x3_rc3::IfcPlanarForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcPlanarForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[766]); }
 void Ifc4x3_rc3::IfcPlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcPlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveInteger
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcPositiveInteger::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[784]); }
+void Ifc4x3_rc3::IfcPositiveInteger::initialize(int v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc3::IfcPositiveInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcPositiveLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[785]); }
+void Ifc4x3_rc3::IfcPositiveLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc3::IfcPositiveLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositivePlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcPositivePlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[786]); }
+void Ifc4x3_rc3::IfcPositivePlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc3::IfcPositivePlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcPositiveRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[787]); }
+void Ifc4x3_rc3::IfcPositiveRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc3::IfcPositiveRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPowerMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[789]); }
 void Ifc4x3_rc3::IfcPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPresentableText
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcPresentableText::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[797]); }
 void Ifc4x3_rc3::IfcPresentableText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcPresentableText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPressureMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[802]); }
 void Ifc4x3_rc3::IfcPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPropertySetDefinitionSet
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcPropertySetDefinitionSet::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[836]); }
 void Ifc4x3_rc3::IfcPropertySetDefinitionSet::initialize(std::vector< ::Ifc4x3_rc3::IfcPropertySetDefinition > v) { set_attribute_value(0, cast_vector<express::Base>(v)); }
+Ifc4x3_rc3::IfcPropertySetDefinitionSet::operator std::vector< ::Ifc4x3_rc3::IfcPropertySetDefinition >() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4x3_rc3::IfcPropertySetDefinition>(es); }
 
 // Function implementations for IfcRadioActivityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcRadioActivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[860]); }
 void Ifc4x3_rc3::IfcRadioActivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcRadioActivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[876]); }
 void Ifc4x3_rc3::IfcRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcReal
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcReal::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[879]); }
 void Ifc4x3_rc3::IfcReal::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcReal::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcRotationalFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[979]); }
 void Ifc4x3_rc3::IfcRotationalFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcRotationalFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalMassMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcRotationalMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[980]); }
 void Ifc4x3_rc3::IfcRotationalMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcRotationalMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcRotationalStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[981]); }
 void Ifc4x3_rc3::IfcRotationalStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcRotationalStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionModulusMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcSectionModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[995]); }
 void Ifc4x3_rc3::IfcSectionModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcSectionModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionalAreaIntegralMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcSectionalAreaIntegralMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[990]); }
 void Ifc4x3_rc3::IfcSectionalAreaIntegralMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcSectionalAreaIntegralMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcShearModulusMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcShearModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1012]); }
 void Ifc4x3_rc3::IfcShearModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcShearModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSolidAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcSolidAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1040]); }
 void Ifc4x3_rc3::IfcSolidAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcSolidAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerLevelMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcSoundPowerLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1044]); }
 void Ifc4x3_rc3::IfcSoundPowerLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcSoundPowerLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcSoundPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1045]); }
 void Ifc4x3_rc3::IfcSoundPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcSoundPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureLevelMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcSoundPressureLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1046]); }
 void Ifc4x3_rc3::IfcSoundPressureLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcSoundPressureLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcSoundPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1047]); }
 void Ifc4x3_rc3::IfcSoundPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcSoundPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecificHeatCapacityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcSpecificHeatCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1063]); }
 void Ifc4x3_rc3::IfcSpecificHeatCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcSpecificHeatCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularExponent
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcSpecularExponent::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1064]); }
 void Ifc4x3_rc3::IfcSpecularExponent::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcSpecularExponent::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularRoughness
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcSpecularRoughness::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1066]); }
 void Ifc4x3_rc3::IfcSpecularRoughness::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcSpecularRoughness::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureGradientMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcTemperatureGradientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1171]); }
 void Ifc4x3_rc3::IfcTemperatureGradientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcTemperatureGradientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureRateOfChangeMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcTemperatureRateOfChangeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1172]); }
 void Ifc4x3_rc3::IfcTemperatureRateOfChangeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcTemperatureRateOfChangeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcText
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcText::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1184]); }
 void Ifc4x3_rc3::IfcText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextAlignment
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcTextAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1185]); }
 void Ifc4x3_rc3::IfcTextAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcTextAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextDecoration
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcTextDecoration::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1186]); }
 void Ifc4x3_rc3::IfcTextDecoration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcTextDecoration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextFontName
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcTextFontName::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1187]); }
 void Ifc4x3_rc3::IfcTextFontName::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcTextFontName::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextTransformation
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcTextTransformation::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1196]); }
 void Ifc4x3_rc3::IfcTextTransformation::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcTextTransformation::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalAdmittanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcThermalAdmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1202]); }
 void Ifc4x3_rc3::IfcThermalAdmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcThermalAdmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalConductivityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcThermalConductivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1203]); }
 void Ifc4x3_rc3::IfcThermalConductivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcThermalConductivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalExpansionCoefficientMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcThermalExpansionCoefficientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1204]); }
 void Ifc4x3_rc3::IfcThermalExpansionCoefficientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcThermalExpansionCoefficientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalResistanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcThermalResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1205]); }
 void Ifc4x3_rc3::IfcThermalResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcThermalResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalTransmittanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcThermalTransmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1206]); }
 void Ifc4x3_rc3::IfcThermalTransmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcThermalTransmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermodynamicTemperatureMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcThermodynamicTemperatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1207]); }
 void Ifc4x3_rc3::IfcThermodynamicTemperatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcThermodynamicTemperatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTime
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcTime::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1209]); }
 void Ifc4x3_rc3::IfcTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcTimeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1210]); }
 void Ifc4x3_rc3::IfcTimeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcTimeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeStamp
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcTimeStamp::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1216]); }
 void Ifc4x3_rc3::IfcTimeStamp::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcTimeStamp::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTorqueMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcTorqueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1220]); }
 void Ifc4x3_rc3::IfcTorqueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcTorqueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcURIReference
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcURIReference::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1257]); }
 void Ifc4x3_rc3::IfcURIReference::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcURIReference::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVaporPermeabilityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcVaporPermeabilityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1263]); }
 void Ifc4x3_rc3::IfcVaporPermeabilityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcVaporPermeabilityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumeMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcVolumeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1281]); }
 void Ifc4x3_rc3::IfcVolumeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcVolumeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumetricFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcVolumetricFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1282]); }
 void Ifc4x3_rc3::IfcVolumetricFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcVolumetricFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingConstantMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcWarpingConstantMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1288]); }
 void Ifc4x3_rc3::IfcWarpingConstantMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcWarpingConstantMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingMomentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc3::IfcWarpingMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC3_types[1289]); }
 void Ifc4x3_rc3::IfcWarpingMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc3::IfcWarpingMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 
 // Function implementations for IfcActionRequest
@@ -8339,8 +8469,8 @@ int Ifc4x3_rc3::IfcBSplineSurface::UDegree() const {  int v = get_attribute_valu
 void Ifc4x3_rc3::IfcBSplineSurface::setUDegree(const int& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
 int Ifc4x3_rc3::IfcBSplineSurface::VDegree() const {  int v = get_attribute_value(1); return v; }
 void Ifc4x3_rc3::IfcBSplineSurface::setVDegree(const int& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
-std::vector< std::vector< ::Ifc4x3_rc3::IfcCartesianPoint > > Ifc4x3_rc3::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector_vector<::Ifc4x3_rc3::IfcCartesianPoint>(es); }
-void Ifc4x3_rc3::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x3_rc3::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
+std::vector< std::vector< ::Ifc4x3_rc3::IfcCartesianPoint > > Ifc4x3_rc3::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector<::Ifc4x3_rc3::IfcCartesianPoint>(es); }
+void Ifc4x3_rc3::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x3_rc3::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
 ::Ifc4x3_rc3::IfcBSplineSurfaceForm::Value Ifc4x3_rc3::IfcBSplineSurface::SurfaceForm() const {  return ::Ifc4x3_rc3::IfcBSplineSurfaceForm::FromString(get_attribute_value(3)); }
 void Ifc4x3_rc3::IfcBSplineSurface::setSurfaceForm(const ::Ifc4x3_rc3::IfcBSplineSurfaceForm::Value& v) { set_attribute_value(3, EnumerationReference(&::Ifc4x3_rc3::IfcBSplineSurfaceForm::Class(), (size_t) v));if constexpr (false)unset_attribute_value(3); }
 boost::logic::tribool Ifc4x3_rc3::IfcBSplineSurface::UClosed() const {  boost::logic::tribool v = get_attribute_value(4); return v; }
diff --git a/src/ifcparse/Ifc4x3_rc4.cpp b/src/ifcparse/Ifc4x3_rc4.cpp
index 2ab8a7df38..b63dfa838d 100644
--- a/src/ifcparse/Ifc4x3_rc4.cpp
+++ b/src/ifcparse/Ifc4x3_rc4.cpp
@@ -7305,522 +7305,652 @@ const IfcParse::select_type& Ifc4x3_rc4::IfcWarpingStiffnessSelect::Class() { re
 // Function implementations for IfcAbsorbedDoseMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcAbsorbedDoseMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[0]); }
 void Ifc4x3_rc4::IfcAbsorbedDoseMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcAbsorbedDoseMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAccelerationMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcAccelerationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1]); }
 void Ifc4x3_rc4::IfcAccelerationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcAccelerationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAmountOfSubstanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcAmountOfSubstanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[42]); }
 void Ifc4x3_rc4::IfcAmountOfSubstanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcAmountOfSubstanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAngularVelocityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcAngularVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[45]); }
 void Ifc4x3_rc4::IfcAngularVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcAngularVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcArcIndex
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcArcIndex::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[57]); }
 void Ifc4x3_rc4::IfcArcIndex::initialize(std::vector< int > /*[3:3]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcArcIndex::operator std::vector< int > /*[3:3]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcAreaDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[58]); }
 void Ifc4x3_rc4::IfcAreaDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcAreaDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcAreaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[59]); }
 void Ifc4x3_rc4::IfcAreaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcAreaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBinary
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcBinary::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[82]); }
 void Ifc4x3_rc4::IfcBinary::initialize(boost::dynamic_bitset<> v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcBinary::operator boost::dynamic_bitset<>() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoolean
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcBoolean::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[88]); }
 void Ifc4x3_rc4::IfcBoolean::initialize(bool v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcBoolean::operator bool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoxAlignment
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcBoxAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[103]); }
+void Ifc4x3_rc4::IfcBoxAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc4::IfcBoxAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCardinalPointReference
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcCardinalPointReference::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[146]); }
 void Ifc4x3_rc4::IfcCardinalPointReference::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcCardinalPointReference::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcComplexNumber
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcComplexNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[190]); }
 void Ifc4x3_rc4::IfcComplexNumber::initialize(std::vector< double > /*[1:2]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcComplexNumber::operator std::vector< double > /*[1:2]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCompoundPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcCompoundPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[198]); }
 void Ifc4x3_rc4::IfcCompoundPlaneAngleMeasure::initialize(std::vector< int > /*[3:4]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcCompoundPlaneAngleMeasure::operator std::vector< int > /*[3:4]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcContextDependentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcContextDependentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[228]); }
 void Ifc4x3_rc4::IfcContextDependentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcContextDependentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCountMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcCountMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[254]); }
 void Ifc4x3_rc4::IfcCountMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcCountMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCurvatureMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcCurvatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[272]); }
 void Ifc4x3_rc4::IfcCurvatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcCurvatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDate
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcDate::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[292]); }
 void Ifc4x3_rc4::IfcDate::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcDate::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDateTime
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcDateTime::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[293]); }
 void Ifc4x3_rc4::IfcDateTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcDateTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInMonthNumber
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcDayInMonthNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[294]); }
 void Ifc4x3_rc4::IfcDayInMonthNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcDayInMonthNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInWeekNumber
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcDayInWeekNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[295]); }
 void Ifc4x3_rc4::IfcDayInWeekNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcDayInWeekNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDescriptiveMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcDescriptiveMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[304]); }
 void Ifc4x3_rc4::IfcDescriptiveMeasure::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcDescriptiveMeasure::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDimensionCount
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcDimensionCount::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[306]); }
 void Ifc4x3_rc4::IfcDimensionCount::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcDimensionCount::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDoseEquivalentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcDoseEquivalentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[349]); }
 void Ifc4x3_rc4::IfcDoseEquivalentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcDoseEquivalentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDuration
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcDuration::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[361]); }
 void Ifc4x3_rc4::IfcDuration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcDuration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDynamicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcDynamicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[362]); }
 void Ifc4x3_rc4::IfcDynamicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcDynamicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCapacitanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcElectricCapacitanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[374]); }
 void Ifc4x3_rc4::IfcElectricCapacitanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcElectricCapacitanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricChargeMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcElectricChargeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[375]); }
 void Ifc4x3_rc4::IfcElectricChargeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcElectricChargeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricConductanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcElectricConductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[376]); }
 void Ifc4x3_rc4::IfcElectricConductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcElectricConductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCurrentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcElectricCurrentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[377]); }
 void Ifc4x3_rc4::IfcElectricCurrentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcElectricCurrentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricResistanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcElectricResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[393]); }
 void Ifc4x3_rc4::IfcElectricResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcElectricResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricVoltageMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcElectricVoltageMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[397]); }
 void Ifc4x3_rc4::IfcElectricVoltageMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcElectricVoltageMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcEnergyMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcEnergyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[412]); }
 void Ifc4x3_rc4::IfcEnergyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcEnergyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontStyle
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcFontStyle::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[493]); }
 void Ifc4x3_rc4::IfcFontStyle::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcFontStyle::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontVariant
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcFontVariant::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[494]); }
 void Ifc4x3_rc4::IfcFontVariant::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcFontVariant::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontWeight
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcFontWeight::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[495]); }
 void Ifc4x3_rc4::IfcFontWeight::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcFontWeight::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcForceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[499]); }
 void Ifc4x3_rc4::IfcForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[500]); }
 void Ifc4x3_rc4::IfcFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcGloballyUniqueId
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcGloballyUniqueId::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[521]); }
 void Ifc4x3_rc4::IfcGloballyUniqueId::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcGloballyUniqueId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcHeatFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[535]); }
 void Ifc4x3_rc4::IfcHeatFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcHeatFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatingValueMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcHeatingValueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[536]); }
 void Ifc4x3_rc4::IfcHeatingValueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcHeatingValueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIdentifier
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcIdentifier::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[540]); }
 void Ifc4x3_rc4::IfcIdentifier::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcIdentifier::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIlluminanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcIlluminanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[541]); }
 void Ifc4x3_rc4::IfcIlluminanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcIlluminanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInductanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcInductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[553]); }
 void Ifc4x3_rc4::IfcInductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcInductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInteger
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcInteger::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[554]); }
 void Ifc4x3_rc4::IfcInteger::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIntegerCountRateMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcIntegerCountRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[555]); }
 void Ifc4x3_rc4::IfcIntegerCountRateMeasure::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcIntegerCountRateMeasure::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIonConcentrationMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcIonConcentrationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[564]); }
 void Ifc4x3_rc4::IfcIonConcentrationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcIonConcentrationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIsothermalMoistureCapacityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcIsothermalMoistureCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[568]); }
 void Ifc4x3_rc4::IfcIsothermalMoistureCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcIsothermalMoistureCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcKinematicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcKinematicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[574]); }
 void Ifc4x3_rc4::IfcKinematicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcKinematicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLabel
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcLabel::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[576]); }
 void Ifc4x3_rc4::IfcLabel::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcLabel::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLanguageId
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcLanguageId::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[584]); }
+void Ifc4x3_rc4::IfcLanguageId::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc4::IfcLanguageId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[587]); }
 void Ifc4x3_rc4::IfcLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLineIndex
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcLineIndex::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[613]); }
 void Ifc4x3_rc4::IfcLineIndex::initialize(std::vector< int > /*[2:?]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcLineIndex::operator std::vector< int > /*[2:?]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearForceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcLinearForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[607]); }
 void Ifc4x3_rc4::IfcLinearForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcLinearForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearMomentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcLinearMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[608]); }
 void Ifc4x3_rc4::IfcLinearMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcLinearMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcLinearStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[611]); }
 void Ifc4x3_rc4::IfcLinearStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcLinearStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearVelocityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcLinearVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[612]); }
 void Ifc4x3_rc4::IfcLinearVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcLinearVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLogical
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcLogical::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[619]); }
 void Ifc4x3_rc4::IfcLogical::initialize(boost::logic::tribool v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcLogical::operator boost::logic::tribool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousFluxMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcLuminousFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[623]); }
 void Ifc4x3_rc4::IfcLuminousFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcLuminousFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityDistributionMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcLuminousIntensityDistributionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[624]); }
 void Ifc4x3_rc4::IfcLuminousIntensityDistributionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcLuminousIntensityDistributionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcLuminousIntensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[625]); }
 void Ifc4x3_rc4::IfcLuminousIntensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcLuminousIntensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcMagneticFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[626]); }
 void Ifc4x3_rc4::IfcMagneticFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcMagneticFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcMagneticFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[627]); }
 void Ifc4x3_rc4::IfcMagneticFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcMagneticFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcMassDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[634]); }
 void Ifc4x3_rc4::IfcMassDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcMassDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcMassFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[635]); }
 void Ifc4x3_rc4::IfcMassFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcMassFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[636]); }
 void Ifc4x3_rc4::IfcMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassPerLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcMassPerLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[637]); }
 void Ifc4x3_rc4::IfcMassPerLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcMassPerLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfElasticityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcModulusOfElasticityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[676]); }
 void Ifc4x3_rc4::IfcModulusOfElasticityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcModulusOfElasticityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfLinearSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcModulusOfLinearSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[677]); }
 void Ifc4x3_rc4::IfcModulusOfLinearSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcModulusOfLinearSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfRotationalSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcModulusOfRotationalSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[678]); }
 void Ifc4x3_rc4::IfcModulusOfRotationalSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcModulusOfRotationalSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcModulusOfSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[680]); }
 void Ifc4x3_rc4::IfcModulusOfSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcModulusOfSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMoistureDiffusivityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcMoistureDiffusivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[683]); }
 void Ifc4x3_rc4::IfcMoistureDiffusivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcMoistureDiffusivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMolecularWeightMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcMolecularWeightMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[684]); }
 void Ifc4x3_rc4::IfcMolecularWeightMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcMolecularWeightMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMomentOfInertiaMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcMomentOfInertiaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[685]); }
 void Ifc4x3_rc4::IfcMomentOfInertiaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcMomentOfInertiaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonetaryMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcMonetaryMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[686]); }
 void Ifc4x3_rc4::IfcMonetaryMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcMonetaryMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonthInYearNumber
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcMonthInYearNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[688]); }
 void Ifc4x3_rc4::IfcMonthInYearNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcMonthInYearNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNonNegativeLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcNonNegativeLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[699]); }
+void Ifc4x3_rc4::IfcNonNegativeLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc4::IfcNonNegativeLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNormalisedRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcNormalisedRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[700]); }
+void Ifc4x3_rc4::IfcNormalisedRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc4::IfcNormalisedRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNumericMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcNumericMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[701]); }
 void Ifc4x3_rc4::IfcNumericMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcNumericMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPHMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcPHMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[743]); }
 void Ifc4x3_rc4::IfcPHMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcPHMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcParameterValue
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcParameterValue::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[729]); }
 void Ifc4x3_rc4::IfcParameterValue::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcParameterValue::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlanarForceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcPlanarForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[762]); }
 void Ifc4x3_rc4::IfcPlanarForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcPlanarForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[764]); }
 void Ifc4x3_rc4::IfcPlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcPlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveInteger
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcPositiveInteger::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[782]); }
+void Ifc4x3_rc4::IfcPositiveInteger::initialize(int v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc4::IfcPositiveInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcPositiveLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[783]); }
+void Ifc4x3_rc4::IfcPositiveLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc4::IfcPositiveLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositivePlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcPositivePlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[784]); }
+void Ifc4x3_rc4::IfcPositivePlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc4::IfcPositivePlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcPositiveRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[785]); }
+void Ifc4x3_rc4::IfcPositiveRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_rc4::IfcPositiveRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPowerMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[787]); }
 void Ifc4x3_rc4::IfcPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPresentableText
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcPresentableText::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[795]); }
 void Ifc4x3_rc4::IfcPresentableText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcPresentableText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPressureMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[800]); }
 void Ifc4x3_rc4::IfcPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPropertySetDefinitionSet
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcPropertySetDefinitionSet::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[834]); }
 void Ifc4x3_rc4::IfcPropertySetDefinitionSet::initialize(std::vector< ::Ifc4x3_rc4::IfcPropertySetDefinition > v) { set_attribute_value(0, cast_vector<express::Base>(v)); }
+Ifc4x3_rc4::IfcPropertySetDefinitionSet::operator std::vector< ::Ifc4x3_rc4::IfcPropertySetDefinition >() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4x3_rc4::IfcPropertySetDefinition>(es); }
 
 // Function implementations for IfcRadioActivityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcRadioActivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[858]); }
 void Ifc4x3_rc4::IfcRadioActivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcRadioActivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[874]); }
 void Ifc4x3_rc4::IfcRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcReal
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcReal::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[877]); }
 void Ifc4x3_rc4::IfcReal::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcReal::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcRotationalFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[978]); }
 void Ifc4x3_rc4::IfcRotationalFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcRotationalFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalMassMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcRotationalMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[979]); }
 void Ifc4x3_rc4::IfcRotationalMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcRotationalMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcRotationalStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[980]); }
 void Ifc4x3_rc4::IfcRotationalStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcRotationalStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionModulusMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcSectionModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[994]); }
 void Ifc4x3_rc4::IfcSectionModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcSectionModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionalAreaIntegralMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcSectionalAreaIntegralMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[989]); }
 void Ifc4x3_rc4::IfcSectionalAreaIntegralMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcSectionalAreaIntegralMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcShearModulusMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcShearModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1012]); }
 void Ifc4x3_rc4::IfcShearModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcShearModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSolidAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcSolidAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1040]); }
 void Ifc4x3_rc4::IfcSolidAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcSolidAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerLevelMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcSoundPowerLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1044]); }
 void Ifc4x3_rc4::IfcSoundPowerLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcSoundPowerLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcSoundPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1045]); }
 void Ifc4x3_rc4::IfcSoundPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcSoundPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureLevelMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcSoundPressureLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1046]); }
 void Ifc4x3_rc4::IfcSoundPressureLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcSoundPressureLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcSoundPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1047]); }
 void Ifc4x3_rc4::IfcSoundPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcSoundPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecificHeatCapacityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcSpecificHeatCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1063]); }
 void Ifc4x3_rc4::IfcSpecificHeatCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcSpecificHeatCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularExponent
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcSpecularExponent::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1064]); }
 void Ifc4x3_rc4::IfcSpecularExponent::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcSpecularExponent::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularRoughness
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcSpecularRoughness::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1066]); }
 void Ifc4x3_rc4::IfcSpecularRoughness::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcSpecularRoughness::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureGradientMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcTemperatureGradientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1171]); }
 void Ifc4x3_rc4::IfcTemperatureGradientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcTemperatureGradientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureRateOfChangeMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcTemperatureRateOfChangeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1172]); }
 void Ifc4x3_rc4::IfcTemperatureRateOfChangeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcTemperatureRateOfChangeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcText
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcText::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1184]); }
 void Ifc4x3_rc4::IfcText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextAlignment
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcTextAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1185]); }
 void Ifc4x3_rc4::IfcTextAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcTextAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextDecoration
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcTextDecoration::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1186]); }
 void Ifc4x3_rc4::IfcTextDecoration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcTextDecoration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextFontName
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcTextFontName::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1187]); }
 void Ifc4x3_rc4::IfcTextFontName::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcTextFontName::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextTransformation
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcTextTransformation::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1196]); }
 void Ifc4x3_rc4::IfcTextTransformation::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcTextTransformation::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalAdmittanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcThermalAdmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1202]); }
 void Ifc4x3_rc4::IfcThermalAdmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcThermalAdmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalConductivityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcThermalConductivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1203]); }
 void Ifc4x3_rc4::IfcThermalConductivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcThermalConductivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalExpansionCoefficientMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcThermalExpansionCoefficientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1204]); }
 void Ifc4x3_rc4::IfcThermalExpansionCoefficientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcThermalExpansionCoefficientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalResistanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcThermalResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1205]); }
 void Ifc4x3_rc4::IfcThermalResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcThermalResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalTransmittanceMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcThermalTransmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1206]); }
 void Ifc4x3_rc4::IfcThermalTransmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcThermalTransmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermodynamicTemperatureMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcThermodynamicTemperatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1207]); }
 void Ifc4x3_rc4::IfcThermodynamicTemperatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcThermodynamicTemperatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTime
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcTime::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1209]); }
 void Ifc4x3_rc4::IfcTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcTimeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1210]); }
 void Ifc4x3_rc4::IfcTimeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcTimeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeStamp
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcTimeStamp::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1216]); }
 void Ifc4x3_rc4::IfcTimeStamp::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcTimeStamp::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTorqueMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcTorqueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1220]); }
 void Ifc4x3_rc4::IfcTorqueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcTorqueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcURIReference
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcURIReference::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1257]); }
 void Ifc4x3_rc4::IfcURIReference::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcURIReference::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVaporPermeabilityMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcVaporPermeabilityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1263]); }
 void Ifc4x3_rc4::IfcVaporPermeabilityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcVaporPermeabilityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumeMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcVolumeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1280]); }
 void Ifc4x3_rc4::IfcVolumeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcVolumeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumetricFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcVolumetricFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1281]); }
 void Ifc4x3_rc4::IfcVolumetricFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcVolumetricFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingConstantMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcWarpingConstantMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1287]); }
 void Ifc4x3_rc4::IfcWarpingConstantMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcWarpingConstantMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingMomentMeasure
 const IfcParse::type_declaration& Ifc4x3_rc4::IfcWarpingMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_RC4_types[1288]); }
 void Ifc4x3_rc4::IfcWarpingMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_rc4::IfcWarpingMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 
 // Function implementations for IfcActionRequest
@@ -8339,8 +8469,8 @@ int Ifc4x3_rc4::IfcBSplineSurface::UDegree() const {  int v = get_attribute_valu
 void Ifc4x3_rc4::IfcBSplineSurface::setUDegree(const int& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
 int Ifc4x3_rc4::IfcBSplineSurface::VDegree() const {  int v = get_attribute_value(1); return v; }
 void Ifc4x3_rc4::IfcBSplineSurface::setVDegree(const int& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
-std::vector< std::vector< ::Ifc4x3_rc4::IfcCartesianPoint > > Ifc4x3_rc4::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector_vector<::Ifc4x3_rc4::IfcCartesianPoint>(es); }
-void Ifc4x3_rc4::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x3_rc4::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
+std::vector< std::vector< ::Ifc4x3_rc4::IfcCartesianPoint > > Ifc4x3_rc4::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector<::Ifc4x3_rc4::IfcCartesianPoint>(es); }
+void Ifc4x3_rc4::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x3_rc4::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
 ::Ifc4x3_rc4::IfcBSplineSurfaceForm::Value Ifc4x3_rc4::IfcBSplineSurface::SurfaceForm() const {  return ::Ifc4x3_rc4::IfcBSplineSurfaceForm::FromString(get_attribute_value(3)); }
 void Ifc4x3_rc4::IfcBSplineSurface::setSurfaceForm(const ::Ifc4x3_rc4::IfcBSplineSurfaceForm::Value& v) { set_attribute_value(3, EnumerationReference(&::Ifc4x3_rc4::IfcBSplineSurfaceForm::Class(), (size_t) v));if constexpr (false)unset_attribute_value(3); }
 boost::logic::tribool Ifc4x3_rc4::IfcBSplineSurface::UClosed() const {  boost::logic::tribool v = get_attribute_value(4); return v; }
diff --git a/src/ifcparse/Ifc4x3_tc1.cpp b/src/ifcparse/Ifc4x3_tc1.cpp
index 0ef3e97aae..d4fe126099 100644
--- a/src/ifcparse/Ifc4x3_tc1.cpp
+++ b/src/ifcparse/Ifc4x3_tc1.cpp
@@ -7212,526 +7212,657 @@ const IfcParse::select_type& Ifc4x3_tc1::IfcWarpingStiffnessSelect::Class() { re
 // Function implementations for IfcAbsorbedDoseMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcAbsorbedDoseMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[0]); }
 void Ifc4x3_tc1::IfcAbsorbedDoseMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcAbsorbedDoseMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAccelerationMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcAccelerationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1]); }
 void Ifc4x3_tc1::IfcAccelerationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcAccelerationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAmountOfSubstanceMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcAmountOfSubstanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[42]); }
 void Ifc4x3_tc1::IfcAmountOfSubstanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcAmountOfSubstanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAngularVelocityMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcAngularVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[45]); }
 void Ifc4x3_tc1::IfcAngularVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcAngularVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcArcIndex
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcArcIndex::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[57]); }
 void Ifc4x3_tc1::IfcArcIndex::initialize(std::vector< int > /*[3:3]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcArcIndex::operator std::vector< int > /*[3:3]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcAreaDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[58]); }
 void Ifc4x3_tc1::IfcAreaDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcAreaDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcAreaMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcAreaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[59]); }
 void Ifc4x3_tc1::IfcAreaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcAreaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBinary
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcBinary::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[80]); }
 void Ifc4x3_tc1::IfcBinary::initialize(boost::dynamic_bitset<> v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcBinary::operator boost::dynamic_bitset<>() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoolean
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcBoolean::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[86]); }
 void Ifc4x3_tc1::IfcBoolean::initialize(bool v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcBoolean::operator bool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcBoxAlignment
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcBoxAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[101]); }
+void Ifc4x3_tc1::IfcBoxAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x3_tc1::IfcBoxAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCardinalPointReference
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcCardinalPointReference::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[145]); }
 void Ifc4x3_tc1::IfcCardinalPointReference::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcCardinalPointReference::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcComplexNumber
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcComplexNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[188]); }
 void Ifc4x3_tc1::IfcComplexNumber::initialize(std::vector< double > /*[1:2]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcComplexNumber::operator std::vector< double > /*[1:2]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCompoundPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcCompoundPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[196]); }
 void Ifc4x3_tc1::IfcCompoundPlaneAngleMeasure::initialize(std::vector< int > /*[3:4]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcCompoundPlaneAngleMeasure::operator std::vector< int > /*[3:4]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcContextDependentMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcContextDependentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[226]); }
 void Ifc4x3_tc1::IfcContextDependentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcContextDependentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCountMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcCountMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[252]); }
 void Ifc4x3_tc1::IfcCountMeasure::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcCountMeasure::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcCurvatureMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcCurvatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[270]); }
 void Ifc4x3_tc1::IfcCurvatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcCurvatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDate
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcDate::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[290]); }
 void Ifc4x3_tc1::IfcDate::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcDate::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDateTime
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcDateTime::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[291]); }
 void Ifc4x3_tc1::IfcDateTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcDateTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInMonthNumber
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcDayInMonthNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[292]); }
 void Ifc4x3_tc1::IfcDayInMonthNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcDayInMonthNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDayInWeekNumber
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcDayInWeekNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[293]); }
 void Ifc4x3_tc1::IfcDayInWeekNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcDayInWeekNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDescriptiveMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcDescriptiveMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[302]); }
 void Ifc4x3_tc1::IfcDescriptiveMeasure::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcDescriptiveMeasure::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDimensionCount
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcDimensionCount::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[304]); }
 void Ifc4x3_tc1::IfcDimensionCount::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcDimensionCount::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDoseEquivalentMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcDoseEquivalentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[343]); }
 void Ifc4x3_tc1::IfcDoseEquivalentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcDoseEquivalentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDuration
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcDuration::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[355]); }
 void Ifc4x3_tc1::IfcDuration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcDuration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcDynamicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcDynamicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[356]); }
 void Ifc4x3_tc1::IfcDynamicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcDynamicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCapacitanceMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcElectricCapacitanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[368]); }
 void Ifc4x3_tc1::IfcElectricCapacitanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcElectricCapacitanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricChargeMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcElectricChargeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[369]); }
 void Ifc4x3_tc1::IfcElectricChargeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcElectricChargeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricConductanceMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcElectricConductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[370]); }
 void Ifc4x3_tc1::IfcElectricConductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcElectricConductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricCurrentMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcElectricCurrentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[371]); }
 void Ifc4x3_tc1::IfcElectricCurrentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcElectricCurrentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricResistanceMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcElectricResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[387]); }
 void Ifc4x3_tc1::IfcElectricResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcElectricResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcElectricVoltageMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcElectricVoltageMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[391]); }
 void Ifc4x3_tc1::IfcElectricVoltageMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcElectricVoltageMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcEnergyMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcEnergyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[406]); }
 void Ifc4x3_tc1::IfcEnergyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcEnergyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontStyle
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcFontStyle::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[487]); }
 void Ifc4x3_tc1::IfcFontStyle::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcFontStyle::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontVariant
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcFontVariant::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[488]); }
 void Ifc4x3_tc1::IfcFontVariant::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcFontVariant::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFontWeight
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcFontWeight::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[489]); }
 void Ifc4x3_tc1::IfcFontWeight::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcFontWeight::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcForceMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[493]); }
 void Ifc4x3_tc1::IfcForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[494]); }
 void Ifc4x3_tc1::IfcFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcGloballyUniqueId
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcGloballyUniqueId::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[516]); }
 void Ifc4x3_tc1::IfcGloballyUniqueId::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcGloballyUniqueId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcHeatFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[530]); }
 void Ifc4x3_tc1::IfcHeatFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcHeatFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcHeatingValueMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcHeatingValueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[531]); }
 void Ifc4x3_tc1::IfcHeatingValueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcHeatingValueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIdentifier
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcIdentifier::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[535]); }
 void Ifc4x3_tc1::IfcIdentifier::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcIdentifier::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIlluminanceMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcIlluminanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[536]); }
 void Ifc4x3_tc1::IfcIlluminanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcIlluminanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInductanceMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcInductanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[548]); }
 void Ifc4x3_tc1::IfcInductanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcInductanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcInteger
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcInteger::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[549]); }
 void Ifc4x3_tc1::IfcInteger::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIntegerCountRateMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcIntegerCountRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[550]); }
 void Ifc4x3_tc1::IfcIntegerCountRateMeasure::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcIntegerCountRateMeasure::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIonConcentrationMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcIonConcentrationMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[559]); }
 void Ifc4x3_tc1::IfcIonConcentrationMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcIonConcentrationMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcIsothermalMoistureCapacityMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcIsothermalMoistureCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[563]); }
 void Ifc4x3_tc1::IfcIsothermalMoistureCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcIsothermalMoistureCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcKinematicViscosityMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcKinematicViscosityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[570]); }
 void Ifc4x3_tc1::IfcKinematicViscosityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcKinematicViscosityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLabel
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcLabel::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[572]); }
 void Ifc4x3_tc1::IfcLabel::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcLabel::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLanguageId
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcLanguageId::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[580]); }
+void Ifc4x3_tc1::IfcLanguageId::initialize(std::string v) { set_attribute_value(0, (v)); }
 Ifc4x3_tc1::IfcLanguageId::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[583]); }
 void Ifc4x3_tc1::IfcLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLineIndex
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcLineIndex::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[609]); }
 void Ifc4x3_tc1::IfcLineIndex::initialize(std::vector< int > /*[2:?]*/ v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcLineIndex::operator std::vector< int > /*[2:?]*/() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearForceMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcLinearForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[603]); }
 void Ifc4x3_tc1::IfcLinearForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcLinearForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearMomentMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcLinearMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[604]); }
 void Ifc4x3_tc1::IfcLinearMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcLinearMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcLinearStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[607]); }
 void Ifc4x3_tc1::IfcLinearStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcLinearStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLinearVelocityMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcLinearVelocityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[608]); }
 void Ifc4x3_tc1::IfcLinearVelocityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcLinearVelocityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLogical
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcLogical::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[615]); }
 void Ifc4x3_tc1::IfcLogical::initialize(boost::logic::tribool v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcLogical::operator boost::logic::tribool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousFluxMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcLuminousFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[619]); }
 void Ifc4x3_tc1::IfcLuminousFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcLuminousFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityDistributionMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcLuminousIntensityDistributionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[620]); }
 void Ifc4x3_tc1::IfcLuminousIntensityDistributionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcLuminousIntensityDistributionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcLuminousIntensityMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcLuminousIntensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[621]); }
 void Ifc4x3_tc1::IfcLuminousIntensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcLuminousIntensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcMagneticFluxDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[622]); }
 void Ifc4x3_tc1::IfcMagneticFluxDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcMagneticFluxDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMagneticFluxMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcMagneticFluxMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[623]); }
 void Ifc4x3_tc1::IfcMagneticFluxMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcMagneticFluxMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassDensityMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcMassDensityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[631]); }
 void Ifc4x3_tc1::IfcMassDensityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcMassDensityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcMassFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[632]); }
 void Ifc4x3_tc1::IfcMassFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcMassFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[633]); }
 void Ifc4x3_tc1::IfcMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMassPerLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcMassPerLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[634]); }
 void Ifc4x3_tc1::IfcMassPerLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcMassPerLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfElasticityMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcModulusOfElasticityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[672]); }
 void Ifc4x3_tc1::IfcModulusOfElasticityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcModulusOfElasticityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfLinearSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcModulusOfLinearSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[673]); }
 void Ifc4x3_tc1::IfcModulusOfLinearSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcModulusOfLinearSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfRotationalSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcModulusOfRotationalSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[674]); }
 void Ifc4x3_tc1::IfcModulusOfRotationalSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcModulusOfRotationalSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcModulusOfSubgradeReactionMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcModulusOfSubgradeReactionMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[676]); }
 void Ifc4x3_tc1::IfcModulusOfSubgradeReactionMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcModulusOfSubgradeReactionMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMoistureDiffusivityMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcMoistureDiffusivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[679]); }
 void Ifc4x3_tc1::IfcMoistureDiffusivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcMoistureDiffusivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMolecularWeightMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcMolecularWeightMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[680]); }
 void Ifc4x3_tc1::IfcMolecularWeightMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcMolecularWeightMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMomentOfInertiaMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcMomentOfInertiaMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[681]); }
 void Ifc4x3_tc1::IfcMomentOfInertiaMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcMomentOfInertiaMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonetaryMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcMonetaryMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[682]); }
 void Ifc4x3_tc1::IfcMonetaryMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcMonetaryMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcMonthInYearNumber
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcMonthInYearNumber::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[684]); }
 void Ifc4x3_tc1::IfcMonthInYearNumber::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcMonthInYearNumber::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNonNegativeLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcNonNegativeLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[695]); }
+void Ifc4x3_tc1::IfcNonNegativeLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_tc1::IfcNonNegativeLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNormalisedRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcNormalisedRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[696]); }
+void Ifc4x3_tc1::IfcNormalisedRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_tc1::IfcNormalisedRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcNumericMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcNumericMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[697]); }
 void Ifc4x3_tc1::IfcNumericMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcNumericMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPHMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcPHMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[737]); }
 void Ifc4x3_tc1::IfcPHMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcPHMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcParameterValue
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcParameterValue::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[723]); }
 void Ifc4x3_tc1::IfcParameterValue::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcParameterValue::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlanarForceMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcPlanarForceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[756]); }
 void Ifc4x3_tc1::IfcPlanarForceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcPlanarForceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcPlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[758]); }
 void Ifc4x3_tc1::IfcPlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcPlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveInteger
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcPositiveInteger::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[774]); }
+void Ifc4x3_tc1::IfcPositiveInteger::initialize(int v) { set_attribute_value(0, (v)); }
 Ifc4x3_tc1::IfcPositiveInteger::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveLengthMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcPositiveLengthMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[775]); }
+void Ifc4x3_tc1::IfcPositiveLengthMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_tc1::IfcPositiveLengthMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositivePlaneAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcPositivePlaneAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[776]); }
+void Ifc4x3_tc1::IfcPositivePlaneAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_tc1::IfcPositivePlaneAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPositiveRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcPositiveRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[777]); }
+void Ifc4x3_tc1::IfcPositiveRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
 Ifc4x3_tc1::IfcPositiveRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPowerMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[779]); }
 void Ifc4x3_tc1::IfcPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPresentableText
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcPresentableText::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[787]); }
 void Ifc4x3_tc1::IfcPresentableText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcPresentableText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPressureMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[792]); }
 void Ifc4x3_tc1::IfcPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcPropertySetDefinitionSet
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcPropertySetDefinitionSet::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[826]); }
 void Ifc4x3_tc1::IfcPropertySetDefinitionSet::initialize(std::vector< ::Ifc4x3_tc1::IfcPropertySetDefinition > v) { set_attribute_value(0, cast_vector<express::Base>(v)); }
+Ifc4x3_tc1::IfcPropertySetDefinitionSet::operator std::vector< ::Ifc4x3_tc1::IfcPropertySetDefinition >() const { std::vector<express::Base> es = get_attribute_value(0); return cast_vector<::Ifc4x3_tc1::IfcPropertySetDefinition>(es); }
 
 // Function implementations for IfcRadioActivityMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcRadioActivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[850]); }
 void Ifc4x3_tc1::IfcRadioActivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcRadioActivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRatioMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcRatioMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[867]); }
 void Ifc4x3_tc1::IfcRatioMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcRatioMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcReal
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcReal::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[870]); }
 void Ifc4x3_tc1::IfcReal::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcReal::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalFrequencyMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcRotationalFrequencyMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[972]); }
 void Ifc4x3_tc1::IfcRotationalFrequencyMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcRotationalFrequencyMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalMassMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcRotationalMassMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[973]); }
 void Ifc4x3_tc1::IfcRotationalMassMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcRotationalMassMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcRotationalStiffnessMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcRotationalStiffnessMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[974]); }
 void Ifc4x3_tc1::IfcRotationalStiffnessMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcRotationalStiffnessMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionModulusMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcSectionModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[988]); }
 void Ifc4x3_tc1::IfcSectionModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcSectionModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSectionalAreaIntegralMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcSectionalAreaIntegralMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[983]); }
 void Ifc4x3_tc1::IfcSectionalAreaIntegralMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcSectionalAreaIntegralMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcShearModulusMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcShearModulusMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1006]); }
 void Ifc4x3_tc1::IfcShearModulusMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcShearModulusMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSolidAngleMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcSolidAngleMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1032]); }
 void Ifc4x3_tc1::IfcSolidAngleMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcSolidAngleMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerLevelMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcSoundPowerLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1035]); }
 void Ifc4x3_tc1::IfcSoundPowerLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcSoundPowerLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPowerMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcSoundPowerMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1036]); }
 void Ifc4x3_tc1::IfcSoundPowerMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcSoundPowerMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureLevelMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcSoundPressureLevelMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1037]); }
 void Ifc4x3_tc1::IfcSoundPressureLevelMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcSoundPressureLevelMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSoundPressureMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcSoundPressureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1038]); }
 void Ifc4x3_tc1::IfcSoundPressureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcSoundPressureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecificHeatCapacityMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcSpecificHeatCapacityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1054]); }
 void Ifc4x3_tc1::IfcSpecificHeatCapacityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcSpecificHeatCapacityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularExponent
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcSpecularExponent::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1055]); }
 void Ifc4x3_tc1::IfcSpecularExponent::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcSpecularExponent::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcSpecularRoughness
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcSpecularRoughness::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1057]); }
 void Ifc4x3_tc1::IfcSpecularRoughness::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcSpecularRoughness::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcStrippedOptional
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcStrippedOptional::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1071]); }
 void Ifc4x3_tc1::IfcStrippedOptional::initialize(bool v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcStrippedOptional::operator bool() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureGradientMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcTemperatureGradientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1163]); }
 void Ifc4x3_tc1::IfcTemperatureGradientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcTemperatureGradientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTemperatureRateOfChangeMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcTemperatureRateOfChangeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1164]); }
 void Ifc4x3_tc1::IfcTemperatureRateOfChangeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcTemperatureRateOfChangeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcText
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcText::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1176]); }
 void Ifc4x3_tc1::IfcText::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcText::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextAlignment
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcTextAlignment::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1177]); }
 void Ifc4x3_tc1::IfcTextAlignment::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcTextAlignment::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextDecoration
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcTextDecoration::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1178]); }
 void Ifc4x3_tc1::IfcTextDecoration::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcTextDecoration::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextFontName
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcTextFontName::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1179]); }
 void Ifc4x3_tc1::IfcTextFontName::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcTextFontName::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTextTransformation
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcTextTransformation::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1188]); }
 void Ifc4x3_tc1::IfcTextTransformation::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcTextTransformation::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalAdmittanceMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcThermalAdmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1196]); }
 void Ifc4x3_tc1::IfcThermalAdmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcThermalAdmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalConductivityMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcThermalConductivityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1197]); }
 void Ifc4x3_tc1::IfcThermalConductivityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcThermalConductivityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalExpansionCoefficientMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcThermalExpansionCoefficientMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1198]); }
 void Ifc4x3_tc1::IfcThermalExpansionCoefficientMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcThermalExpansionCoefficientMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalResistanceMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcThermalResistanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1199]); }
 void Ifc4x3_tc1::IfcThermalResistanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcThermalResistanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermalTransmittanceMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcThermalTransmittanceMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1200]); }
 void Ifc4x3_tc1::IfcThermalTransmittanceMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcThermalTransmittanceMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcThermodynamicTemperatureMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcThermodynamicTemperatureMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1201]); }
 void Ifc4x3_tc1::IfcThermodynamicTemperatureMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcThermodynamicTemperatureMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTime
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcTime::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1203]); }
 void Ifc4x3_tc1::IfcTime::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcTime::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcTimeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1204]); }
 void Ifc4x3_tc1::IfcTimeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcTimeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTimeStamp
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcTimeStamp::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1210]); }
 void Ifc4x3_tc1::IfcTimeStamp::initialize(int v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcTimeStamp::operator int() const { return get_attribute_value(0); }
 
 // Function implementations for IfcTorqueMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcTorqueMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1214]); }
 void Ifc4x3_tc1::IfcTorqueMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcTorqueMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcURIReference
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcURIReference::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1251]); }
 void Ifc4x3_tc1::IfcURIReference::initialize(std::string v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcURIReference::operator std::string() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVaporPermeabilityMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcVaporPermeabilityMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1257]); }
 void Ifc4x3_tc1::IfcVaporPermeabilityMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcVaporPermeabilityMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumeMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcVolumeMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1277]); }
 void Ifc4x3_tc1::IfcVolumeMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcVolumeMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcVolumetricFlowRateMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcVolumetricFlowRateMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1278]); }
 void Ifc4x3_tc1::IfcVolumetricFlowRateMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcVolumetricFlowRateMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingConstantMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcWarpingConstantMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1283]); }
 void Ifc4x3_tc1::IfcWarpingConstantMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcWarpingConstantMeasure::operator double() const { return get_attribute_value(0); }
 
 // Function implementations for IfcWarpingMomentMeasure
 const IfcParse::type_declaration& Ifc4x3_tc1::IfcWarpingMomentMeasure::Class() { return *((IfcParse::type_declaration*)IFC4X3_TC1_types[1284]); }
 void Ifc4x3_tc1::IfcWarpingMomentMeasure::initialize(double v) { set_attribute_value(0, (v)); }
+Ifc4x3_tc1::IfcWarpingMomentMeasure::operator double() const { return get_attribute_value(0); }
 
 
 // Function implementations for IfcActionRequest
@@ -8250,8 +8381,8 @@ int Ifc4x3_tc1::IfcBSplineSurface::UDegree() const {  int v = get_attribute_valu
 void Ifc4x3_tc1::IfcBSplineSurface::setUDegree(const int& v) { set_attribute_value(0, v);if constexpr (false)unset_attribute_value(0); }
 int Ifc4x3_tc1::IfcBSplineSurface::VDegree() const {  int v = get_attribute_value(1); return v; }
 void Ifc4x3_tc1::IfcBSplineSurface::setVDegree(const int& v) { set_attribute_value(1, v);if constexpr (false)unset_attribute_value(1); }
-std::vector< std::vector< ::Ifc4x3_tc1::IfcCartesianPoint > > Ifc4x3_tc1::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector_vector<::Ifc4x3_tc1::IfcCartesianPoint>(es); }
-void Ifc4x3_tc1::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x3_tc1::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
+std::vector< std::vector< ::Ifc4x3_tc1::IfcCartesianPoint > > Ifc4x3_tc1::IfcBSplineSurface::ControlPointsList() const {  std::vector<std::vector<express::Base>> es = get_attribute_value(2); return cast_vector<::Ifc4x3_tc1::IfcCartesianPoint>(es); }
+void Ifc4x3_tc1::IfcBSplineSurface::setControlPointsList(const std::vector< std::vector< ::Ifc4x3_tc1::IfcCartesianPoint > >& v) { set_attribute_value(2, cast_vector<express::Base>(v));if constexpr (false)unset_attribute_value(2); }
 ::Ifc4x3_tc1::IfcBSplineSurfaceForm::Value Ifc4x3_tc1::IfcBSplineSurface::SurfaceForm() const {  return ::Ifc4x3_tc1::IfcBSplineSurfaceForm::FromString(get_attribute_value(3)); }
 void Ifc4x3_tc1::IfcBSplineSurface::setSurfaceForm(const ::Ifc4x3_tc1::IfcBSplineSurfaceForm::Value& v) { set_attribute_value(3, EnumerationReference(&::Ifc4x3_tc1::IfcBSplineSurfaceForm::Class(), (size_t) v));if constexpr (false)unset_attribute_value(3); }
 boost::logic::tribool Ifc4x3_tc1::IfcBSplineSurface::UClosed() const {  boost::logic::tribool v = get_attribute_value(4); return v; }