Glassvision/IfcOpenShell
1
0
Fork 0
mirror of https://github.com/IfcOpenShell/IfcOpenShell.git synced 2026-08-11 18:16:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

Introduce specific exception for out of range attribute indexing

Browse Source
This commit is contained in:
Thomas Krijnen
2015-06-17 11:04:28 +00:00
parent 381f711103
commit 1ec14118fe
10 changed files with 748 additions and 742 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/ifcexpressparser/header.py
+3 -3
View File
@@ -95,17 +95,17 @@ class Header:
argument_start = argument_count - len(type.attributes)
argument_name_function_body_switch_stmt = " switch (i) {%s}"%("".join(['case %d: return "%s"; '%(i+argument_start, attr.name) for i, attr in enumerate(type.attributes)])) if len(type.attributes) else ""
argument_name_function_body_tail = (" return %s::getArgumentName(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' throw IfcParse::IfcException("argument out of range"); '
argument_name_function_body_tail = (" return %s::getArgumentName(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); '
argument_name_function_body = argument_name_function_body_switch_stmt + argument_name_function_body_tail
argument_type_function_body_switch_stmt = " switch (i) {%s}"%("".join(['case %d: return %s; '%(i+argument_start, mapping.make_argument_type(attr)) for i, attr in enumerate(type.attributes)])) if len(type.attributes) else ""
argument_type_function_body_tail = (" return %s::getArgumentType(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' throw IfcParse::IfcException("argument out of range"); '
argument_type_function_body_tail = (" return %s::getArgumentType(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); '
argument_type_function_body = argument_type_function_body_switch_stmt + argument_type_function_body_tail
argument_entity_function_body_switch_stmt = " switch (i) {%s}"%("".join(['case %d: return %s; '%(i+argument_start, mapping.make_argument_entity(attr)) for i, attr in enumerate(type.attributes)])) if len(type.attributes) else ""
argument_entity_function_body_tail = (" return %s::getArgumentEntity(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' throw IfcParse::IfcException("argument out of range"); '
argument_entity_function_body_tail = (" return %s::getArgumentEntity(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); '
argument_entity_function_body = argument_entity_function_body_switch_stmt + argument_entity_function_body_tail
src/ifcexpressparser/templates.py
+1 -1
View File
@@ -338,7 +338,7 @@ public:
"""
simpletype_impl_comment = "// Function implementations for %(name)s"
simpletype_impl_argument_type = "if (i == 0) { return %(attr_type)s; } else { throw IfcParse::IfcException(\"argument out of range\"); }"
simpletype_impl_argument_type = "if (i == 0) { return %(attr_type)s; } else { throw IfcParse::IfcAttributeOutOfRangeException(\"Argument index out of range\"); }"
simpletype_impl_argument = "return entity->getArgument(i);"
simpletype_impl_is_with_supertype = "return v == Type::%(class_name)s || %(superclass)s::is(v);"
simpletype_impl_is_without_supertype = "return v == %(class_name)s::Class();"
src/ifcparse/Ifc2x3.cpp
+117 -117
View File
@@ -5322,7 +5322,7 @@ IfcWorkControlTypeEnum::IfcWorkControlTypeEnum IfcWorkControlTypeEnum::FromStrin
// Function implementations for IfcAbsorbedDoseMeasure
IfcUtil::ArgumentType IfcAbsorbedDoseMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcAbsorbedDoseMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcAbsorbedDoseMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcAbsorbedDoseMeasure::is(Type::Enum v) const { return v == IfcAbsorbedDoseMeasure::Class(); }
Type::Enum IfcAbsorbedDoseMeasure::type() const { return Type::IfcAbsorbedDoseMeasure; }
@@ -5332,7 +5332,7 @@ IfcAbsorbedDoseMeasure::IfcAbsorbedDoseMeasure(double v) { IfcWritableEntity* e
IfcAbsorbedDoseMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcAccelerationMeasure
IfcUtil::ArgumentType IfcAccelerationMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcAccelerationMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcAccelerationMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcAccelerationMeasure::is(Type::Enum v) const { return v == IfcAccelerationMeasure::Class(); }
Type::Enum IfcAccelerationMeasure::type() const { return Type::IfcAccelerationMeasure; }
@@ -5342,7 +5342,7 @@ IfcAccelerationMeasure::IfcAccelerationMeasure(double v) { IfcWritableEntity* e
IfcAccelerationMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcAmountOfSubstanceMeasure
IfcUtil::ArgumentType IfcAmountOfSubstanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcAmountOfSubstanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcAmountOfSubstanceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcAmountOfSubstanceMeasure::is(Type::Enum v) const { return v == IfcAmountOfSubstanceMeasure::Class(); }
Type::Enum IfcAmountOfSubstanceMeasure::type() const { return Type::IfcAmountOfSubstanceMeasure; }
@@ -5352,7 +5352,7 @@ IfcAmountOfSubstanceMeasure::IfcAmountOfSubstanceMeasure(double v) { IfcWritable
IfcAmountOfSubstanceMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcAngularVelocityMeasure
IfcUtil::ArgumentType IfcAngularVelocityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcAngularVelocityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcAngularVelocityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcAngularVelocityMeasure::is(Type::Enum v) const { return v == IfcAngularVelocityMeasure::Class(); }
Type::Enum IfcAngularVelocityMeasure::type() const { return Type::IfcAngularVelocityMeasure; }
@@ -5362,7 +5362,7 @@ IfcAngularVelocityMeasure::IfcAngularVelocityMeasure(double v) { IfcWritableEnti
IfcAngularVelocityMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcAreaMeasure
IfcUtil::ArgumentType IfcAreaMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcAreaMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcAreaMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcAreaMeasure::is(Type::Enum v) const { return v == IfcAreaMeasure::Class(); }
Type::Enum IfcAreaMeasure::type() const { return Type::IfcAreaMeasure; }
@@ -5372,7 +5372,7 @@ IfcAreaMeasure::IfcAreaMeasure(double v) { IfcWritableEntity* e = new IfcWritabl
IfcAreaMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcBoolean
IfcUtil::ArgumentType IfcBoolean::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_BOOL; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcBoolean::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_BOOL; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcBoolean::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcBoolean::is(Type::Enum v) const { return v == IfcBoolean::Class(); }
Type::Enum IfcBoolean::type() const { return Type::IfcBoolean; }
@@ -5382,7 +5382,7 @@ IfcBoolean::IfcBoolean(bool v) { IfcWritableEntity* e = new IfcWritableEntity(Ty
IfcBoolean::operator bool() const { return *entity->getArgument(0); }
// Function implementations for IfcBoxAlignment
IfcUtil::ArgumentType IfcBoxAlignment::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcBoxAlignment::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcBoxAlignment::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcBoxAlignment::is(Type::Enum v) const { return v == Type::IfcBoxAlignment || IfcLabel::is(v); }
Type::Enum IfcBoxAlignment::type() const { return Type::IfcBoxAlignment; }
@@ -5392,7 +5392,7 @@ IfcBoxAlignment::IfcBoxAlignment(std::string v) : IfcLabel((IfcAbstractEntity*)0
IfcBoxAlignment::operator std::string() const { return *entity->getArgument(0); }
// Function implementations for IfcComplexNumber
IfcUtil::ArgumentType IfcComplexNumber::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcComplexNumber::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcComplexNumber::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcComplexNumber::is(Type::Enum v) const { return v == IfcComplexNumber::Class(); }
Type::Enum IfcComplexNumber::type() const { return Type::IfcComplexNumber; }
@@ -5402,7 +5402,7 @@ IfcComplexNumber::IfcComplexNumber(std::vector< double > /*[1:2]*/ v) { IfcWrita
IfcComplexNumber::operator std::vector< double > /*[1:2]*/() const { return *entity->getArgument(0); }
// Function implementations for IfcCompoundPlaneAngleMeasure
IfcUtil::ArgumentType IfcCompoundPlaneAngleMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcCompoundPlaneAngleMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcCompoundPlaneAngleMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcCompoundPlaneAngleMeasure::is(Type::Enum v) const { return v == IfcCompoundPlaneAngleMeasure::Class(); }
Type::Enum IfcCompoundPlaneAngleMeasure::type() const { return Type::IfcCompoundPlaneAngleMeasure; }
@@ -5412,7 +5412,7 @@ IfcCompoundPlaneAngleMeasure::IfcCompoundPlaneAngleMeasure(std::vector< int > /*
IfcCompoundPlaneAngleMeasure::operator std::vector< int > /*[3:4]*/() const { return *entity->getArgument(0); }
// Function implementations for IfcContextDependentMeasure
IfcUtil::ArgumentType IfcContextDependentMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcContextDependentMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcContextDependentMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcContextDependentMeasure::is(Type::Enum v) const { return v == IfcContextDependentMeasure::Class(); }
Type::Enum IfcContextDependentMeasure::type() const { return Type::IfcContextDependentMeasure; }
@@ -5422,7 +5422,7 @@ IfcContextDependentMeasure::IfcContextDependentMeasure(double v) { IfcWritableEn
IfcContextDependentMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcCountMeasure
IfcUtil::ArgumentType IfcCountMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcCountMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcCountMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcCountMeasure::is(Type::Enum v) const { return v == IfcCountMeasure::Class(); }
Type::Enum IfcCountMeasure::type() const { return Type::IfcCountMeasure; }
@@ -5432,7 +5432,7 @@ IfcCountMeasure::IfcCountMeasure(double v) { IfcWritableEntity* e = new IfcWrita
IfcCountMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcCurvatureMeasure
IfcUtil::ArgumentType IfcCurvatureMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcCurvatureMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcCurvatureMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcCurvatureMeasure::is(Type::Enum v) const { return v == IfcCurvatureMeasure::Class(); }
Type::Enum IfcCurvatureMeasure::type() const { return Type::IfcCurvatureMeasure; }
@@ -5442,7 +5442,7 @@ IfcCurvatureMeasure::IfcCurvatureMeasure(double v) { IfcWritableEntity* e = new
IfcCurvatureMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcDayInMonthNumber
IfcUtil::ArgumentType IfcDayInMonthNumber::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcDayInMonthNumber::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcDayInMonthNumber::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcDayInMonthNumber::is(Type::Enum v) const { return v == IfcDayInMonthNumber::Class(); }
Type::Enum IfcDayInMonthNumber::type() const { return Type::IfcDayInMonthNumber; }
@@ -5452,7 +5452,7 @@ IfcDayInMonthNumber::IfcDayInMonthNumber(int v) { IfcWritableEntity* e = new Ifc
IfcDayInMonthNumber::operator int() const { return *entity->getArgument(0); }
// Function implementations for IfcDaylightSavingHour
IfcUtil::ArgumentType IfcDaylightSavingHour::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcDaylightSavingHour::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcDaylightSavingHour::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcDaylightSavingHour::is(Type::Enum v) const { return v == IfcDaylightSavingHour::Class(); }
Type::Enum IfcDaylightSavingHour::type() const { return Type::IfcDaylightSavingHour; }
@@ -5462,7 +5462,7 @@ IfcDaylightSavingHour::IfcDaylightSavingHour(int v) { IfcWritableEntity* e = new
IfcDaylightSavingHour::operator int() const { return *entity->getArgument(0); }
// Function implementations for IfcDescriptiveMeasure
IfcUtil::ArgumentType IfcDescriptiveMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcDescriptiveMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcDescriptiveMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcDescriptiveMeasure::is(Type::Enum v) const { return v == IfcDescriptiveMeasure::Class(); }
Type::Enum IfcDescriptiveMeasure::type() const { return Type::IfcDescriptiveMeasure; }
@@ -5472,7 +5472,7 @@ IfcDescriptiveMeasure::IfcDescriptiveMeasure(std::string v) { IfcWritableEntity*
IfcDescriptiveMeasure::operator std::string() const { return *entity->getArgument(0); }
// Function implementations for IfcDimensionCount
IfcUtil::ArgumentType IfcDimensionCount::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcDimensionCount::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcDimensionCount::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcDimensionCount::is(Type::Enum v) const { return v == IfcDimensionCount::Class(); }
Type::Enum IfcDimensionCount::type() const { return Type::IfcDimensionCount; }
@@ -5482,7 +5482,7 @@ IfcDimensionCount::IfcDimensionCount(int v) { IfcWritableEntity* e = new IfcWrit
IfcDimensionCount::operator int() const { return *entity->getArgument(0); }
// Function implementations for IfcDoseEquivalentMeasure
IfcUtil::ArgumentType IfcDoseEquivalentMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcDoseEquivalentMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcDoseEquivalentMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcDoseEquivalentMeasure::is(Type::Enum v) const { return v == IfcDoseEquivalentMeasure::Class(); }
Type::Enum IfcDoseEquivalentMeasure::type() const { return Type::IfcDoseEquivalentMeasure; }
@@ -5492,7 +5492,7 @@ IfcDoseEquivalentMeasure::IfcDoseEquivalentMeasure(double v) { IfcWritableEntity
IfcDoseEquivalentMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcDynamicViscosityMeasure
IfcUtil::ArgumentType IfcDynamicViscosityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcDynamicViscosityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcDynamicViscosityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcDynamicViscosityMeasure::is(Type::Enum v) const { return v == IfcDynamicViscosityMeasure::Class(); }
Type::Enum IfcDynamicViscosityMeasure::type() const { return Type::IfcDynamicViscosityMeasure; }
@@ -5502,7 +5502,7 @@ IfcDynamicViscosityMeasure::IfcDynamicViscosityMeasure(double v) { IfcWritableEn
IfcDynamicViscosityMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcElectricCapacitanceMeasure
IfcUtil::ArgumentType IfcElectricCapacitanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcElectricCapacitanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcElectricCapacitanceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcElectricCapacitanceMeasure::is(Type::Enum v) const { return v == IfcElectricCapacitanceMeasure::Class(); }
Type::Enum IfcElectricCapacitanceMeasure::type() const { return Type::IfcElectricCapacitanceMeasure; }
@@ -5512,7 +5512,7 @@ IfcElectricCapacitanceMeasure::IfcElectricCapacitanceMeasure(double v) { IfcWrit
IfcElectricCapacitanceMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcElectricChargeMeasure
IfcUtil::ArgumentType IfcElectricChargeMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcElectricChargeMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcElectricChargeMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcElectricChargeMeasure::is(Type::Enum v) const { return v == IfcElectricChargeMeasure::Class(); }
Type::Enum IfcElectricChargeMeasure::type() const { return Type::IfcElectricChargeMeasure; }
@@ -5522,7 +5522,7 @@ IfcElectricChargeMeasure::IfcElectricChargeMeasure(double v) { IfcWritableEntity
IfcElectricChargeMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcElectricConductanceMeasure
IfcUtil::ArgumentType IfcElectricConductanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcElectricConductanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcElectricConductanceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcElectricConductanceMeasure::is(Type::Enum v) const { return v == IfcElectricConductanceMeasure::Class(); }
Type::Enum IfcElectricConductanceMeasure::type() const { return Type::IfcElectricConductanceMeasure; }
@@ -5532,7 +5532,7 @@ IfcElectricConductanceMeasure::IfcElectricConductanceMeasure(double v) { IfcWrit
IfcElectricConductanceMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcElectricCurrentMeasure
IfcUtil::ArgumentType IfcElectricCurrentMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcElectricCurrentMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcElectricCurrentMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcElectricCurrentMeasure::is(Type::Enum v) const { return v == IfcElectricCurrentMeasure::Class(); }
Type::Enum IfcElectricCurrentMeasure::type() const { return Type::IfcElectricCurrentMeasure; }
@@ -5542,7 +5542,7 @@ IfcElectricCurrentMeasure::IfcElectricCurrentMeasure(double v) { IfcWritableEnti
IfcElectricCurrentMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcElectricResistanceMeasure
IfcUtil::ArgumentType IfcElectricResistanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcElectricResistanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcElectricResistanceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcElectricResistanceMeasure::is(Type::Enum v) const { return v == IfcElectricResistanceMeasure::Class(); }
Type::Enum IfcElectricResistanceMeasure::type() const { return Type::IfcElectricResistanceMeasure; }
@@ -5552,7 +5552,7 @@ IfcElectricResistanceMeasure::IfcElectricResistanceMeasure(double v) { IfcWritab
IfcElectricResistanceMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcElectricVoltageMeasure
IfcUtil::ArgumentType IfcElectricVoltageMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcElectricVoltageMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcElectricVoltageMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcElectricVoltageMeasure::is(Type::Enum v) const { return v == IfcElectricVoltageMeasure::Class(); }
Type::Enum IfcElectricVoltageMeasure::type() const { return Type::IfcElectricVoltageMeasure; }
@@ -5562,7 +5562,7 @@ IfcElectricVoltageMeasure::IfcElectricVoltageMeasure(double v) { IfcWritableEnti
IfcElectricVoltageMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcEnergyMeasure
IfcUtil::ArgumentType IfcEnergyMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcEnergyMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcEnergyMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcEnergyMeasure::is(Type::Enum v) const { return v == IfcEnergyMeasure::Class(); }
Type::Enum IfcEnergyMeasure::type() const { return Type::IfcEnergyMeasure; }
@@ -5572,7 +5572,7 @@ IfcEnergyMeasure::IfcEnergyMeasure(double v) { IfcWritableEntity* e = new IfcWri
IfcEnergyMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcFontStyle
IfcUtil::ArgumentType IfcFontStyle::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcFontStyle::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcFontStyle::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcFontStyle::is(Type::Enum v) const { return v == IfcFontStyle::Class(); }
Type::Enum IfcFontStyle::type() const { return Type::IfcFontStyle; }
@@ -5582,7 +5582,7 @@ IfcFontStyle::IfcFontStyle(std::string v) { IfcWritableEntity* e = new IfcWritab
IfcFontStyle::operator std::string() const { return *entity->getArgument(0); }
// Function implementations for IfcFontVariant
IfcUtil::ArgumentType IfcFontVariant::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcFontVariant::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcFontVariant::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcFontVariant::is(Type::Enum v) const { return v == IfcFontVariant::Class(); }
Type::Enum IfcFontVariant::type() const { return Type::IfcFontVariant; }
@@ -5592,7 +5592,7 @@ IfcFontVariant::IfcFontVariant(std::string v) { IfcWritableEntity* e = new IfcWr
IfcFontVariant::operator std::string() const { return *entity->getArgument(0); }
// Function implementations for IfcFontWeight
IfcUtil::ArgumentType IfcFontWeight::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcFontWeight::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcFontWeight::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcFontWeight::is(Type::Enum v) const { return v == IfcFontWeight::Class(); }
Type::Enum IfcFontWeight::type() const { return Type::IfcFontWeight; }
@@ -5602,7 +5602,7 @@ IfcFontWeight::IfcFontWeight(std::string v) { IfcWritableEntity* e = new IfcWrit
IfcFontWeight::operator std::string() const { return *entity->getArgument(0); }
// Function implementations for IfcForceMeasure
IfcUtil::ArgumentType IfcForceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcForceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcForceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcForceMeasure::is(Type::Enum v) const { return v == IfcForceMeasure::Class(); }
Type::Enum IfcForceMeasure::type() const { return Type::IfcForceMeasure; }
@@ -5612,7 +5612,7 @@ IfcForceMeasure::IfcForceMeasure(double v) { IfcWritableEntity* e = new IfcWrita
IfcForceMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcFrequencyMeasure
IfcUtil::ArgumentType IfcFrequencyMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcFrequencyMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcFrequencyMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcFrequencyMeasure::is(Type::Enum v) const { return v == IfcFrequencyMeasure::Class(); }
Type::Enum IfcFrequencyMeasure::type() const { return Type::IfcFrequencyMeasure; }
@@ -5622,7 +5622,7 @@ IfcFrequencyMeasure::IfcFrequencyMeasure(double v) { IfcWritableEntity* e = new
IfcFrequencyMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcGloballyUniqueId
IfcUtil::ArgumentType IfcGloballyUniqueId::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcGloballyUniqueId::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcGloballyUniqueId::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcGloballyUniqueId::is(Type::Enum v) const { return v == IfcGloballyUniqueId::Class(); }
Type::Enum IfcGloballyUniqueId::type() const { return Type::IfcGloballyUniqueId; }
@@ -5632,7 +5632,7 @@ IfcGloballyUniqueId::IfcGloballyUniqueId(std::string v) { IfcWritableEntity* e =
IfcGloballyUniqueId::operator std::string() const { return *entity->getArgument(0); }
// Function implementations for IfcHeatFluxDensityMeasure
IfcUtil::ArgumentType IfcHeatFluxDensityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcHeatFluxDensityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcHeatFluxDensityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcHeatFluxDensityMeasure::is(Type::Enum v) const { return v == IfcHeatFluxDensityMeasure::Class(); }
Type::Enum IfcHeatFluxDensityMeasure::type() const { return Type::IfcHeatFluxDensityMeasure; }
@@ -5642,7 +5642,7 @@ IfcHeatFluxDensityMeasure::IfcHeatFluxDensityMeasure(double v) { IfcWritableEnti
IfcHeatFluxDensityMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcHeatingValueMeasure
IfcUtil::ArgumentType IfcHeatingValueMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcHeatingValueMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcHeatingValueMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcHeatingValueMeasure::is(Type::Enum v) const { return v == IfcHeatingValueMeasure::Class(); }
Type::Enum IfcHeatingValueMeasure::type() const { return Type::IfcHeatingValueMeasure; }
@@ -5652,7 +5652,7 @@ IfcHeatingValueMeasure::IfcHeatingValueMeasure(double v) { IfcWritableEntity* e
IfcHeatingValueMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcHourInDay
IfcUtil::ArgumentType IfcHourInDay::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcHourInDay::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcHourInDay::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcHourInDay::is(Type::Enum v) const { return v == IfcHourInDay::Class(); }
Type::Enum IfcHourInDay::type() const { return Type::IfcHourInDay; }
@@ -5662,7 +5662,7 @@ IfcHourInDay::IfcHourInDay(int v) { IfcWritableEntity* e = new IfcWritableEntity
IfcHourInDay::operator int() const { return *entity->getArgument(0); }
// Function implementations for IfcIdentifier
IfcUtil::ArgumentType IfcIdentifier::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcIdentifier::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcIdentifier::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcIdentifier::is(Type::Enum v) const { return v == IfcIdentifier::Class(); }
Type::Enum IfcIdentifier::type() const { return Type::IfcIdentifier; }
@@ -5672,7 +5672,7 @@ IfcIdentifier::IfcIdentifier(std::string v) { IfcWritableEntity* e = new IfcWrit
IfcIdentifier::operator std::string() const { return *entity->getArgument(0); }
// Function implementations for IfcIlluminanceMeasure
IfcUtil::ArgumentType IfcIlluminanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcIlluminanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcIlluminanceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcIlluminanceMeasure::is(Type::Enum v) const { return v == IfcIlluminanceMeasure::Class(); }
Type::Enum IfcIlluminanceMeasure::type() const { return Type::IfcIlluminanceMeasure; }
@@ -5682,7 +5682,7 @@ IfcIlluminanceMeasure::IfcIlluminanceMeasure(double v) { IfcWritableEntity* e =
IfcIlluminanceMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcInductanceMeasure
IfcUtil::ArgumentType IfcInductanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcInductanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcInductanceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcInductanceMeasure::is(Type::Enum v) const { return v == IfcInductanceMeasure::Class(); }
Type::Enum IfcInductanceMeasure::type() const { return Type::IfcInductanceMeasure; }
@@ -5692,7 +5692,7 @@ IfcInductanceMeasure::IfcInductanceMeasure(double v) { IfcWritableEntity* e = ne
IfcInductanceMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcInteger
IfcUtil::ArgumentType IfcInteger::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcInteger::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcInteger::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcInteger::is(Type::Enum v) const { return v == IfcInteger::Class(); }
Type::Enum IfcInteger::type() const { return Type::IfcInteger; }
@@ -5702,7 +5702,7 @@ IfcInteger::IfcInteger(int v) { IfcWritableEntity* e = new IfcWritableEntity(Typ
IfcInteger::operator int() const { return *entity->getArgument(0); }
// Function implementations for IfcIntegerCountRateMeasure
IfcUtil::ArgumentType IfcIntegerCountRateMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcIntegerCountRateMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcIntegerCountRateMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcIntegerCountRateMeasure::is(Type::Enum v) const { return v == IfcIntegerCountRateMeasure::Class(); }
Type::Enum IfcIntegerCountRateMeasure::type() const { return Type::IfcIntegerCountRateMeasure; }
@@ -5712,7 +5712,7 @@ IfcIntegerCountRateMeasure::IfcIntegerCountRateMeasure(int v) { IfcWritableEntit
IfcIntegerCountRateMeasure::operator int() const { return *entity->getArgument(0); }
// Function implementations for IfcIonConcentrationMeasure
IfcUtil::ArgumentType IfcIonConcentrationMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcIonConcentrationMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcIonConcentrationMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcIonConcentrationMeasure::is(Type::Enum v) const { return v == IfcIonConcentrationMeasure::Class(); }
Type::Enum IfcIonConcentrationMeasure::type() const { return Type::IfcIonConcentrationMeasure; }
@@ -5722,7 +5722,7 @@ IfcIonConcentrationMeasure::IfcIonConcentrationMeasure(double v) { IfcWritableEn
IfcIonConcentrationMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcIsothermalMoistureCapacityMeasure
IfcUtil::ArgumentType IfcIsothermalMoistureCapacityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcIsothermalMoistureCapacityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcIsothermalMoistureCapacityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcIsothermalMoistureCapacityMeasure::is(Type::Enum v) const { return v == IfcIsothermalMoistureCapacityMeasure::Class(); }
Type::Enum IfcIsothermalMoistureCapacityMeasure::type() const { return Type::IfcIsothermalMoistureCapacityMeasure; }
@@ -5732,7 +5732,7 @@ IfcIsothermalMoistureCapacityMeasure::IfcIsothermalMoistureCapacityMeasure(doubl
IfcIsothermalMoistureCapacityMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcKinematicViscosityMeasure
IfcUtil::ArgumentType IfcKinematicViscosityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcKinematicViscosityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcKinematicViscosityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcKinematicViscosityMeasure::is(Type::Enum v) const { return v == IfcKinematicViscosityMeasure::Class(); }
Type::Enum IfcKinematicViscosityMeasure::type() const { return Type::IfcKinematicViscosityMeasure; }
@@ -5742,7 +5742,7 @@ IfcKinematicViscosityMeasure::IfcKinematicViscosityMeasure(double v) { IfcWritab
IfcKinematicViscosityMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcLabel
IfcUtil::ArgumentType IfcLabel::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcLabel::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcLabel::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcLabel::is(Type::Enum v) const { return v == IfcLabel::Class(); }
Type::Enum IfcLabel::type() const { return Type::IfcLabel; }
@@ -5752,7 +5752,7 @@ IfcLabel::IfcLabel(std::string v) { IfcWritableEntity* e = new IfcWritableEntity
IfcLabel::operator std::string() const { return *entity->getArgument(0); }
// Function implementations for IfcLengthMeasure
IfcUtil::ArgumentType IfcLengthMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcLengthMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcLengthMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcLengthMeasure::is(Type::Enum v) const { return v == IfcLengthMeasure::Class(); }
Type::Enum IfcLengthMeasure::type() const { return Type::IfcLengthMeasure; }
@@ -5762,7 +5762,7 @@ IfcLengthMeasure::IfcLengthMeasure(double v) { IfcWritableEntity* e = new IfcWri
IfcLengthMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcLinearForceMeasure
IfcUtil::ArgumentType IfcLinearForceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcLinearForceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcLinearForceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcLinearForceMeasure::is(Type::Enum v) const { return v == IfcLinearForceMeasure::Class(); }
Type::Enum IfcLinearForceMeasure::type() const { return Type::IfcLinearForceMeasure; }
@@ -5772,7 +5772,7 @@ IfcLinearForceMeasure::IfcLinearForceMeasure(double v) { IfcWritableEntity* e =
IfcLinearForceMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcLinearMomentMeasure
IfcUtil::ArgumentType IfcLinearMomentMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcLinearMomentMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcLinearMomentMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcLinearMomentMeasure::is(Type::Enum v) const { return v == IfcLinearMomentMeasure::Class(); }
Type::Enum IfcLinearMomentMeasure::type() const { return Type::IfcLinearMomentMeasure; }
@@ -5782,7 +5782,7 @@ IfcLinearMomentMeasure::IfcLinearMomentMeasure(double v) { IfcWritableEntity* e
IfcLinearMomentMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcLinearStiffnessMeasure
IfcUtil::ArgumentType IfcLinearStiffnessMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcLinearStiffnessMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcLinearStiffnessMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcLinearStiffnessMeasure::is(Type::Enum v) const { return v == IfcLinearStiffnessMeasure::Class(); }
Type::Enum IfcLinearStiffnessMeasure::type() const { return Type::IfcLinearStiffnessMeasure; }
@@ -5792,7 +5792,7 @@ IfcLinearStiffnessMeasure::IfcLinearStiffnessMeasure(double v) { IfcWritableEnti
IfcLinearStiffnessMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcLinearVelocityMeasure
IfcUtil::ArgumentType IfcLinearVelocityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcLinearVelocityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcLinearVelocityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcLinearVelocityMeasure::is(Type::Enum v) const { return v == IfcLinearVelocityMeasure::Class(); }
Type::Enum IfcLinearVelocityMeasure::type() const { return Type::IfcLinearVelocityMeasure; }
@@ -5802,7 +5802,7 @@ IfcLinearVelocityMeasure::IfcLinearVelocityMeasure(double v) { IfcWritableEntity
IfcLinearVelocityMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcLogical
IfcUtil::ArgumentType IfcLogical::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_BOOL; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcLogical::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_BOOL; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcLogical::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcLogical::is(Type::Enum v) const { return v == IfcLogical::Class(); }
Type::Enum IfcLogical::type() const { return Type::IfcLogical; }
@@ -5812,7 +5812,7 @@ IfcLogical::IfcLogical(bool v) { IfcWritableEntity* e = new IfcWritableEntity(Ty
IfcLogical::operator bool() const { return *entity->getArgument(0); }
// Function implementations for IfcLuminousFluxMeasure
IfcUtil::ArgumentType IfcLuminousFluxMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcLuminousFluxMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcLuminousFluxMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcLuminousFluxMeasure::is(Type::Enum v) const { return v == IfcLuminousFluxMeasure::Class(); }
Type::Enum IfcLuminousFluxMeasure::type() const { return Type::IfcLuminousFluxMeasure; }
@@ -5822,7 +5822,7 @@ IfcLuminousFluxMeasure::IfcLuminousFluxMeasure(double v) { IfcWritableEntity* e
IfcLuminousFluxMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcLuminousIntensityDistributionMeasure
IfcUtil::ArgumentType IfcLuminousIntensityDistributionMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcLuminousIntensityDistributionMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcLuminousIntensityDistributionMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcLuminousIntensityDistributionMeasure::is(Type::Enum v) const { return v == IfcLuminousIntensityDistributionMeasure::Class(); }
Type::Enum IfcLuminousIntensityDistributionMeasure::type() const { return Type::IfcLuminousIntensityDistributionMeasure; }
@@ -5832,7 +5832,7 @@ IfcLuminousIntensityDistributionMeasure::IfcLuminousIntensityDistributionMeasure
IfcLuminousIntensityDistributionMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcLuminousIntensityMeasure
IfcUtil::ArgumentType IfcLuminousIntensityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcLuminousIntensityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcLuminousIntensityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcLuminousIntensityMeasure::is(Type::Enum v) const { return v == IfcLuminousIntensityMeasure::Class(); }
Type::Enum IfcLuminousIntensityMeasure::type() const { return Type::IfcLuminousIntensityMeasure; }
@@ -5842,7 +5842,7 @@ IfcLuminousIntensityMeasure::IfcLuminousIntensityMeasure(double v) { IfcWritable
IfcLuminousIntensityMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcMagneticFluxDensityMeasure
IfcUtil::ArgumentType IfcMagneticFluxDensityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcMagneticFluxDensityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcMagneticFluxDensityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcMagneticFluxDensityMeasure::is(Type::Enum v) const { return v == IfcMagneticFluxDensityMeasure::Class(); }
Type::Enum IfcMagneticFluxDensityMeasure::type() const { return Type::IfcMagneticFluxDensityMeasure; }
@@ -5852,7 +5852,7 @@ IfcMagneticFluxDensityMeasure::IfcMagneticFluxDensityMeasure(double v) { IfcWrit
IfcMagneticFluxDensityMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcMagneticFluxMeasure
IfcUtil::ArgumentType IfcMagneticFluxMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcMagneticFluxMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcMagneticFluxMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcMagneticFluxMeasure::is(Type::Enum v) const { return v == IfcMagneticFluxMeasure::Class(); }
Type::Enum IfcMagneticFluxMeasure::type() const { return Type::IfcMagneticFluxMeasure; }
@@ -5862,7 +5862,7 @@ IfcMagneticFluxMeasure::IfcMagneticFluxMeasure(double v) { IfcWritableEntity* e
IfcMagneticFluxMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcMassDensityMeasure
IfcUtil::ArgumentType IfcMassDensityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcMassDensityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcMassDensityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcMassDensityMeasure::is(Type::Enum v) const { return v == IfcMassDensityMeasure::Class(); }
Type::Enum IfcMassDensityMeasure::type() const { return Type::IfcMassDensityMeasure; }
@@ -5872,7 +5872,7 @@ IfcMassDensityMeasure::IfcMassDensityMeasure(double v) { IfcWritableEntity* e =
IfcMassDensityMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcMassFlowRateMeasure
IfcUtil::ArgumentType IfcMassFlowRateMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcMassFlowRateMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcMassFlowRateMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcMassFlowRateMeasure::is(Type::Enum v) const { return v == IfcMassFlowRateMeasure::Class(); }
Type::Enum IfcMassFlowRateMeasure::type() const { return Type::IfcMassFlowRateMeasure; }
@@ -5882,7 +5882,7 @@ IfcMassFlowRateMeasure::IfcMassFlowRateMeasure(double v) { IfcWritableEntity* e
IfcMassFlowRateMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcMassMeasure
IfcUtil::ArgumentType IfcMassMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcMassMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcMassMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcMassMeasure::is(Type::Enum v) const { return v == IfcMassMeasure::Class(); }
Type::Enum IfcMassMeasure::type() const { return Type::IfcMassMeasure; }
@@ -5892,7 +5892,7 @@ IfcMassMeasure::IfcMassMeasure(double v) { IfcWritableEntity* e = new IfcWritabl
IfcMassMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcMassPerLengthMeasure
IfcUtil::ArgumentType IfcMassPerLengthMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcMassPerLengthMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcMassPerLengthMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcMassPerLengthMeasure::is(Type::Enum v) const { return v == IfcMassPerLengthMeasure::Class(); }
Type::Enum IfcMassPerLengthMeasure::type() const { return Type::IfcMassPerLengthMeasure; }
@@ -5902,7 +5902,7 @@ IfcMassPerLengthMeasure::IfcMassPerLengthMeasure(double v) { IfcWritableEntity*
IfcMassPerLengthMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcMinuteInHour
IfcUtil::ArgumentType IfcMinuteInHour::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcMinuteInHour::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcMinuteInHour::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcMinuteInHour::is(Type::Enum v) const { return v == IfcMinuteInHour::Class(); }
Type::Enum IfcMinuteInHour::type() const { return Type::IfcMinuteInHour; }
@@ -5912,7 +5912,7 @@ IfcMinuteInHour::IfcMinuteInHour(int v) { IfcWritableEntity* e = new IfcWritable
IfcMinuteInHour::operator int() const { return *entity->getArgument(0); }
// Function implementations for IfcModulusOfElasticityMeasure
IfcUtil::ArgumentType IfcModulusOfElasticityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcModulusOfElasticityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcModulusOfElasticityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcModulusOfElasticityMeasure::is(Type::Enum v) const { return v == IfcModulusOfElasticityMeasure::Class(); }
Type::Enum IfcModulusOfElasticityMeasure::type() const { return Type::IfcModulusOfElasticityMeasure; }
@@ -5922,7 +5922,7 @@ IfcModulusOfElasticityMeasure::IfcModulusOfElasticityMeasure(double v) { IfcWrit
IfcModulusOfElasticityMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcModulusOfLinearSubgradeReactionMeasure
IfcUtil::ArgumentType IfcModulusOfLinearSubgradeReactionMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcModulusOfLinearSubgradeReactionMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcModulusOfLinearSubgradeReactionMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcModulusOfLinearSubgradeReactionMeasure::is(Type::Enum v) const { return v == IfcModulusOfLinearSubgradeReactionMeasure::Class(); }
Type::Enum IfcModulusOfLinearSubgradeReactionMeasure::type() const { return Type::IfcModulusOfLinearSubgradeReactionMeasure; }
@@ -5932,7 +5932,7 @@ IfcModulusOfLinearSubgradeReactionMeasure::IfcModulusOfLinearSubgradeReactionMea
IfcModulusOfLinearSubgradeReactionMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcModulusOfRotationalSubgradeReactionMeasure
IfcUtil::ArgumentType IfcModulusOfRotationalSubgradeReactionMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcModulusOfRotationalSubgradeReactionMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcModulusOfRotationalSubgradeReactionMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcModulusOfRotationalSubgradeReactionMeasure::is(Type::Enum v) const { return v == IfcModulusOfRotationalSubgradeReactionMeasure::Class(); }
Type::Enum IfcModulusOfRotationalSubgradeReactionMeasure::type() const { return Type::IfcModulusOfRotationalSubgradeReactionMeasure; }
@@ -5942,7 +5942,7 @@ IfcModulusOfRotationalSubgradeReactionMeasure::IfcModulusOfRotationalSubgradeRea
IfcModulusOfRotationalSubgradeReactionMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcModulusOfSubgradeReactionMeasure
IfcUtil::ArgumentType IfcModulusOfSubgradeReactionMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcModulusOfSubgradeReactionMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcModulusOfSubgradeReactionMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcModulusOfSubgradeReactionMeasure::is(Type::Enum v) const { return v == IfcModulusOfSubgradeReactionMeasure::Class(); }
Type::Enum IfcModulusOfSubgradeReactionMeasure::type() const { return Type::IfcModulusOfSubgradeReactionMeasure; }
@@ -5952,7 +5952,7 @@ IfcModulusOfSubgradeReactionMeasure::IfcModulusOfSubgradeReactionMeasure(double
IfcModulusOfSubgradeReactionMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcMoistureDiffusivityMeasure
IfcUtil::ArgumentType IfcMoistureDiffusivityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcMoistureDiffusivityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcMoistureDiffusivityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcMoistureDiffusivityMeasure::is(Type::Enum v) const { return v == IfcMoistureDiffusivityMeasure::Class(); }
Type::Enum IfcMoistureDiffusivityMeasure::type() const { return Type::IfcMoistureDiffusivityMeasure; }
@@ -5962,7 +5962,7 @@ IfcMoistureDiffusivityMeasure::IfcMoistureDiffusivityMeasure(double v) { IfcWrit
IfcMoistureDiffusivityMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcMolecularWeightMeasure
IfcUtil::ArgumentType IfcMolecularWeightMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcMolecularWeightMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcMolecularWeightMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcMolecularWeightMeasure::is(Type::Enum v) const { return v == IfcMolecularWeightMeasure::Class(); }
Type::Enum IfcMolecularWeightMeasure::type() const { return Type::IfcMolecularWeightMeasure; }
@@ -5972,7 +5972,7 @@ IfcMolecularWeightMeasure::IfcMolecularWeightMeasure(double v) { IfcWritableEnti
IfcMolecularWeightMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcMomentOfInertiaMeasure
IfcUtil::ArgumentType IfcMomentOfInertiaMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcMomentOfInertiaMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcMomentOfInertiaMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcMomentOfInertiaMeasure::is(Type::Enum v) const { return v == IfcMomentOfInertiaMeasure::Class(); }
Type::Enum IfcMomentOfInertiaMeasure::type() const { return Type::IfcMomentOfInertiaMeasure; }
@@ -5982,7 +5982,7 @@ IfcMomentOfInertiaMeasure::IfcMomentOfInertiaMeasure(double v) { IfcWritableEnti
IfcMomentOfInertiaMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcMonetaryMeasure
IfcUtil::ArgumentType IfcMonetaryMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcMonetaryMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcMonetaryMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcMonetaryMeasure::is(Type::Enum v) const { return v == IfcMonetaryMeasure::Class(); }
Type::Enum IfcMonetaryMeasure::type() const { return Type::IfcMonetaryMeasure; }
@@ -5992,7 +5992,7 @@ IfcMonetaryMeasure::IfcMonetaryMeasure(double v) { IfcWritableEntity* e = new If
IfcMonetaryMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcMonthInYearNumber
IfcUtil::ArgumentType IfcMonthInYearNumber::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcMonthInYearNumber::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcMonthInYearNumber::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcMonthInYearNumber::is(Type::Enum v) const { return v == IfcMonthInYearNumber::Class(); }
Type::Enum IfcMonthInYearNumber::type() const { return Type::IfcMonthInYearNumber; }
@@ -6002,7 +6002,7 @@ IfcMonthInYearNumber::IfcMonthInYearNumber(int v) { IfcWritableEntity* e = new I
IfcMonthInYearNumber::operator int() const { return *entity->getArgument(0); }
// Function implementations for IfcNormalisedRatioMeasure
IfcUtil::ArgumentType IfcNormalisedRatioMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcNormalisedRatioMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcNormalisedRatioMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcNormalisedRatioMeasure::is(Type::Enum v) const { return v == Type::IfcNormalisedRatioMeasure || IfcRatioMeasure::is(v); }
Type::Enum IfcNormalisedRatioMeasure::type() const { return Type::IfcNormalisedRatioMeasure; }
@@ -6012,7 +6012,7 @@ IfcNormalisedRatioMeasure::IfcNormalisedRatioMeasure(double v) : IfcRatioMeasure
IfcNormalisedRatioMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcNumericMeasure
IfcUtil::ArgumentType IfcNumericMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcNumericMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcNumericMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcNumericMeasure::is(Type::Enum v) const { return v == IfcNumericMeasure::Class(); }
Type::Enum IfcNumericMeasure::type() const { return Type::IfcNumericMeasure; }
@@ -6022,7 +6022,7 @@ IfcNumericMeasure::IfcNumericMeasure(double v) { IfcWritableEntity* e = new IfcW
IfcNumericMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcPHMeasure
IfcUtil::ArgumentType IfcPHMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcPHMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcPHMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcPHMeasure::is(Type::Enum v) const { return v == IfcPHMeasure::Class(); }
Type::Enum IfcPHMeasure::type() const { return Type::IfcPHMeasure; }
@@ -6032,7 +6032,7 @@ IfcPHMeasure::IfcPHMeasure(double v) { IfcWritableEntity* e = new IfcWritableEnt
IfcPHMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcParameterValue
IfcUtil::ArgumentType IfcParameterValue::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcParameterValue::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcParameterValue::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcParameterValue::is(Type::Enum v) const { return v == IfcParameterValue::Class(); }
Type::Enum IfcParameterValue::type() const { return Type::IfcParameterValue; }
@@ -6042,7 +6042,7 @@ IfcParameterValue::IfcParameterValue(double v) { IfcWritableEntity* e = new IfcW
IfcParameterValue::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcPlanarForceMeasure
IfcUtil::ArgumentType IfcPlanarForceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcPlanarForceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcPlanarForceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcPlanarForceMeasure::is(Type::Enum v) const { return v == IfcPlanarForceMeasure::Class(); }
Type::Enum IfcPlanarForceMeasure::type() const { return Type::IfcPlanarForceMeasure; }
@@ -6052,7 +6052,7 @@ IfcPlanarForceMeasure::IfcPlanarForceMeasure(double v) { IfcWritableEntity* e =
IfcPlanarForceMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcPlaneAngleMeasure
IfcUtil::ArgumentType IfcPlaneAngleMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcPlaneAngleMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcPlaneAngleMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcPlaneAngleMeasure::is(Type::Enum v) const { return v == IfcPlaneAngleMeasure::Class(); }
Type::Enum IfcPlaneAngleMeasure::type() const { return Type::IfcPlaneAngleMeasure; }
@@ -6062,7 +6062,7 @@ IfcPlaneAngleMeasure::IfcPlaneAngleMeasure(double v) { IfcWritableEntity* e = ne
IfcPlaneAngleMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcPositiveLengthMeasure
IfcUtil::ArgumentType IfcPositiveLengthMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcPositiveLengthMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcPositiveLengthMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcPositiveLengthMeasure::is(Type::Enum v) const { return v == Type::IfcPositiveLengthMeasure || IfcLengthMeasure::is(v); }
Type::Enum IfcPositiveLengthMeasure::type() const { return Type::IfcPositiveLengthMeasure; }
@@ -6072,7 +6072,7 @@ IfcPositiveLengthMeasure::IfcPositiveLengthMeasure(double v) : IfcLengthMeasure(
IfcPositiveLengthMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcPositivePlaneAngleMeasure
IfcUtil::ArgumentType IfcPositivePlaneAngleMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcPositivePlaneAngleMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcPositivePlaneAngleMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcPositivePlaneAngleMeasure::is(Type::Enum v) const { return v == Type::IfcPositivePlaneAngleMeasure || IfcPlaneAngleMeasure::is(v); }
Type::Enum IfcPositivePlaneAngleMeasure::type() const { return Type::IfcPositivePlaneAngleMeasure; }
@@ -6082,7 +6082,7 @@ IfcPositivePlaneAngleMeasure::IfcPositivePlaneAngleMeasure(double v) : IfcPlaneA
IfcPositivePlaneAngleMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcPositiveRatioMeasure
IfcUtil::ArgumentType IfcPositiveRatioMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcPositiveRatioMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcPositiveRatioMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcPositiveRatioMeasure::is(Type::Enum v) const { return v == Type::IfcPositiveRatioMeasure || IfcRatioMeasure::is(v); }
Type::Enum IfcPositiveRatioMeasure::type() const { return Type::IfcPositiveRatioMeasure; }
@@ -6092,7 +6092,7 @@ IfcPositiveRatioMeasure::IfcPositiveRatioMeasure(double v) : IfcRatioMeasure((If
IfcPositiveRatioMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcPowerMeasure
IfcUtil::ArgumentType IfcPowerMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcPowerMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcPowerMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcPowerMeasure::is(Type::Enum v) const { return v == IfcPowerMeasure::Class(); }
Type::Enum IfcPowerMeasure::type() const { return Type::IfcPowerMeasure; }
@@ -6102,7 +6102,7 @@ IfcPowerMeasure::IfcPowerMeasure(double v) { IfcWritableEntity* e = new IfcWrita
IfcPowerMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcPresentableText
IfcUtil::ArgumentType IfcPresentableText::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcPresentableText::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcPresentableText::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcPresentableText::is(Type::Enum v) const { return v == IfcPresentableText::Class(); }
Type::Enum IfcPresentableText::type() const { return Type::IfcPresentableText; }
@@ -6112,7 +6112,7 @@ IfcPresentableText::IfcPresentableText(std::string v) { IfcWritableEntity* e = n
IfcPresentableText::operator std::string() const { return *entity->getArgument(0); }
// Function implementations for IfcPressureMeasure
IfcUtil::ArgumentType IfcPressureMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcPressureMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcPressureMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcPressureMeasure::is(Type::Enum v) const { return v == IfcPressureMeasure::Class(); }
Type::Enum IfcPressureMeasure::type() const { return Type::IfcPressureMeasure; }
@@ -6122,7 +6122,7 @@ IfcPressureMeasure::IfcPressureMeasure(double v) { IfcWritableEntity* e = new If
IfcPressureMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcRadioActivityMeasure
IfcUtil::ArgumentType IfcRadioActivityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcRadioActivityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcRadioActivityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcRadioActivityMeasure::is(Type::Enum v) const { return v == IfcRadioActivityMeasure::Class(); }
Type::Enum IfcRadioActivityMeasure::type() const { return Type::IfcRadioActivityMeasure; }
@@ -6132,7 +6132,7 @@ IfcRadioActivityMeasure::IfcRadioActivityMeasure(double v) { IfcWritableEntity*
IfcRadioActivityMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcRatioMeasure
IfcUtil::ArgumentType IfcRatioMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcRatioMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcRatioMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcRatioMeasure::is(Type::Enum v) const { return v == IfcRatioMeasure::Class(); }
Type::Enum IfcRatioMeasure::type() const { return Type::IfcRatioMeasure; }
@@ -6142,7 +6142,7 @@ IfcRatioMeasure::IfcRatioMeasure(double v) { IfcWritableEntity* e = new IfcWrita
IfcRatioMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcReal
IfcUtil::ArgumentType IfcReal::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcReal::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcReal::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcReal::is(Type::Enum v) const { return v == IfcReal::Class(); }
Type::Enum IfcReal::type() const { return Type::IfcReal; }
@@ -6152,7 +6152,7 @@ IfcReal::IfcReal(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::
IfcReal::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcRotationalFrequencyMeasure
IfcUtil::ArgumentType IfcRotationalFrequencyMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcRotationalFrequencyMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcRotationalFrequencyMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcRotationalFrequencyMeasure::is(Type::Enum v) const { return v == IfcRotationalFrequencyMeasure::Class(); }
Type::Enum IfcRotationalFrequencyMeasure::type() const { return Type::IfcRotationalFrequencyMeasure; }
@@ -6162,7 +6162,7 @@ IfcRotationalFrequencyMeasure::IfcRotationalFrequencyMeasure(double v) { IfcWrit
IfcRotationalFrequencyMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcRotationalMassMeasure
IfcUtil::ArgumentType IfcRotationalMassMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcRotationalMassMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcRotationalMassMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcRotationalMassMeasure::is(Type::Enum v) const { return v == IfcRotationalMassMeasure::Class(); }
Type::Enum IfcRotationalMassMeasure::type() const { return Type::IfcRotationalMassMeasure; }
@@ -6172,7 +6172,7 @@ IfcRotationalMassMeasure::IfcRotationalMassMeasure(double v) { IfcWritableEntity
IfcRotationalMassMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcRotationalStiffnessMeasure
IfcUtil::ArgumentType IfcRotationalStiffnessMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcRotationalStiffnessMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcRotationalStiffnessMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcRotationalStiffnessMeasure::is(Type::Enum v) const { return v == IfcRotationalStiffnessMeasure::Class(); }
Type::Enum IfcRotationalStiffnessMeasure::type() const { return Type::IfcRotationalStiffnessMeasure; }
@@ -6182,7 +6182,7 @@ IfcRotationalStiffnessMeasure::IfcRotationalStiffnessMeasure(double v) { IfcWrit
IfcRotationalStiffnessMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcSecondInMinute
IfcUtil::ArgumentType IfcSecondInMinute::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcSecondInMinute::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcSecondInMinute::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcSecondInMinute::is(Type::Enum v) const { return v == IfcSecondInMinute::Class(); }
Type::Enum IfcSecondInMinute::type() const { return Type::IfcSecondInMinute; }
@@ -6192,7 +6192,7 @@ IfcSecondInMinute::IfcSecondInMinute(double v) { IfcWritableEntity* e = new IfcW
IfcSecondInMinute::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcSectionModulusMeasure
IfcUtil::ArgumentType IfcSectionModulusMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcSectionModulusMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcSectionModulusMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcSectionModulusMeasure::is(Type::Enum v) const { return v == IfcSectionModulusMeasure::Class(); }
Type::Enum IfcSectionModulusMeasure::type() const { return Type::IfcSectionModulusMeasure; }
@@ -6202,7 +6202,7 @@ IfcSectionModulusMeasure::IfcSectionModulusMeasure(double v) { IfcWritableEntity
IfcSectionModulusMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcSectionalAreaIntegralMeasure
IfcUtil::ArgumentType IfcSectionalAreaIntegralMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcSectionalAreaIntegralMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcSectionalAreaIntegralMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcSectionalAreaIntegralMeasure::is(Type::Enum v) const { return v == IfcSectionalAreaIntegralMeasure::Class(); }
Type::Enum IfcSectionalAreaIntegralMeasure::type() const { return Type::IfcSectionalAreaIntegralMeasure; }
@@ -6212,7 +6212,7 @@ IfcSectionalAreaIntegralMeasure::IfcSectionalAreaIntegralMeasure(double v) { Ifc
IfcSectionalAreaIntegralMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcShearModulusMeasure
IfcUtil::ArgumentType IfcShearModulusMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcShearModulusMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcShearModulusMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcShearModulusMeasure::is(Type::Enum v) const { return v == IfcShearModulusMeasure::Class(); }
Type::Enum IfcShearModulusMeasure::type() const { return Type::IfcShearModulusMeasure; }
@@ -6222,7 +6222,7 @@ IfcShearModulusMeasure::IfcShearModulusMeasure(double v) { IfcWritableEntity* e
IfcShearModulusMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcSolidAngleMeasure
IfcUtil::ArgumentType IfcSolidAngleMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcSolidAngleMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcSolidAngleMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcSolidAngleMeasure::is(Type::Enum v) const { return v == IfcSolidAngleMeasure::Class(); }
Type::Enum IfcSolidAngleMeasure::type() const { return Type::IfcSolidAngleMeasure; }
@@ -6232,7 +6232,7 @@ IfcSolidAngleMeasure::IfcSolidAngleMeasure(double v) { IfcWritableEntity* e = ne
IfcSolidAngleMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcSoundPowerMeasure
IfcUtil::ArgumentType IfcSoundPowerMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcSoundPowerMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcSoundPowerMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcSoundPowerMeasure::is(Type::Enum v) const { return v == IfcSoundPowerMeasure::Class(); }
Type::Enum IfcSoundPowerMeasure::type() const { return Type::IfcSoundPowerMeasure; }
@@ -6242,7 +6242,7 @@ IfcSoundPowerMeasure::IfcSoundPowerMeasure(double v) { IfcWritableEntity* e = ne
IfcSoundPowerMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcSoundPressureMeasure
IfcUtil::ArgumentType IfcSoundPressureMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcSoundPressureMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcSoundPressureMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcSoundPressureMeasure::is(Type::Enum v) const { return v == IfcSoundPressureMeasure::Class(); }
Type::Enum IfcSoundPressureMeasure::type() const { return Type::IfcSoundPressureMeasure; }
@@ -6252,7 +6252,7 @@ IfcSoundPressureMeasure::IfcSoundPressureMeasure(double v) { IfcWritableEntity*
IfcSoundPressureMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcSpecificHeatCapacityMeasure
IfcUtil::ArgumentType IfcSpecificHeatCapacityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcSpecificHeatCapacityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcSpecificHeatCapacityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcSpecificHeatCapacityMeasure::is(Type::Enum v) const { return v == IfcSpecificHeatCapacityMeasure::Class(); }
Type::Enum IfcSpecificHeatCapacityMeasure::type() const { return Type::IfcSpecificHeatCapacityMeasure; }
@@ -6262,7 +6262,7 @@ IfcSpecificHeatCapacityMeasure::IfcSpecificHeatCapacityMeasure(double v) { IfcWr
IfcSpecificHeatCapacityMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcSpecularExponent
IfcUtil::ArgumentType IfcSpecularExponent::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcSpecularExponent::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcSpecularExponent::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcSpecularExponent::is(Type::Enum v) const { return v == IfcSpecularExponent::Class(); }
Type::Enum IfcSpecularExponent::type() const { return Type::IfcSpecularExponent; }
@@ -6272,7 +6272,7 @@ IfcSpecularExponent::IfcSpecularExponent(double v) { IfcWritableEntity* e = new
IfcSpecularExponent::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcSpecularRoughness
IfcUtil::ArgumentType IfcSpecularRoughness::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcSpecularRoughness::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcSpecularRoughness::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcSpecularRoughness::is(Type::Enum v) const { return v == IfcSpecularRoughness::Class(); }
Type::Enum IfcSpecularRoughness::type() const { return Type::IfcSpecularRoughness; }
@@ -6282,7 +6282,7 @@ IfcSpecularRoughness::IfcSpecularRoughness(double v) { IfcWritableEntity* e = ne
IfcSpecularRoughness::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcTemperatureGradientMeasure
IfcUtil::ArgumentType IfcTemperatureGradientMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcTemperatureGradientMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcTemperatureGradientMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcTemperatureGradientMeasure::is(Type::Enum v) const { return v == IfcTemperatureGradientMeasure::Class(); }
Type::Enum IfcTemperatureGradientMeasure::type() const { return Type::IfcTemperatureGradientMeasure; }
@@ -6292,7 +6292,7 @@ IfcTemperatureGradientMeasure::IfcTemperatureGradientMeasure(double v) { IfcWrit
IfcTemperatureGradientMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcText
IfcUtil::ArgumentType IfcText::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcText::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcText::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcText::is(Type::Enum v) const { return v == IfcText::Class(); }
Type::Enum IfcText::type() const { return Type::IfcText; }
@@ -6302,7 +6302,7 @@ IfcText::IfcText(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(T
IfcText::operator std::string() const { return *entity->getArgument(0); }
// Function implementations for IfcTextAlignment
IfcUtil::ArgumentType IfcTextAlignment::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcTextAlignment::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcTextAlignment::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcTextAlignment::is(Type::Enum v) const { return v == IfcTextAlignment::Class(); }
Type::Enum IfcTextAlignment::type() const { return Type::IfcTextAlignment; }
@@ -6312,7 +6312,7 @@ IfcTextAlignment::IfcTextAlignment(std::string v) { IfcWritableEntity* e = new I
IfcTextAlignment::operator std::string() const { return *entity->getArgument(0); }
// Function implementations for IfcTextDecoration
IfcUtil::ArgumentType IfcTextDecoration::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcTextDecoration::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcTextDecoration::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcTextDecoration::is(Type::Enum v) const { return v == IfcTextDecoration::Class(); }
Type::Enum IfcTextDecoration::type() const { return Type::IfcTextDecoration; }
@@ -6322,7 +6322,7 @@ IfcTextDecoration::IfcTextDecoration(std::string v) { IfcWritableEntity* e = new
IfcTextDecoration::operator std::string() const { return *entity->getArgument(0); }
// Function implementations for IfcTextFontName
IfcUtil::ArgumentType IfcTextFontName::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcTextFontName::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcTextFontName::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcTextFontName::is(Type::Enum v) const { return v == IfcTextFontName::Class(); }
Type::Enum IfcTextFontName::type() const { return Type::IfcTextFontName; }
@@ -6332,7 +6332,7 @@ IfcTextFontName::IfcTextFontName(std::string v) { IfcWritableEntity* e = new Ifc
IfcTextFontName::operator std::string() const { return *entity->getArgument(0); }
// Function implementations for IfcTextTransformation
IfcUtil::ArgumentType IfcTextTransformation::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcTextTransformation::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcTextTransformation::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcTextTransformation::is(Type::Enum v) const { return v == IfcTextTransformation::Class(); }
Type::Enum IfcTextTransformation::type() const { return Type::IfcTextTransformation; }
@@ -6342,7 +6342,7 @@ IfcTextTransformation::IfcTextTransformation(std::string v) { IfcWritableEntity*
IfcTextTransformation::operator std::string() const { return *entity->getArgument(0); }
// Function implementations for IfcThermalAdmittanceMeasure
IfcUtil::ArgumentType IfcThermalAdmittanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcThermalAdmittanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcThermalAdmittanceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcThermalAdmittanceMeasure::is(Type::Enum v) const { return v == IfcThermalAdmittanceMeasure::Class(); }
Type::Enum IfcThermalAdmittanceMeasure::type() const { return Type::IfcThermalAdmittanceMeasure; }
@@ -6352,7 +6352,7 @@ IfcThermalAdmittanceMeasure::IfcThermalAdmittanceMeasure(double v) { IfcWritable
IfcThermalAdmittanceMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcThermalConductivityMeasure
IfcUtil::ArgumentType IfcThermalConductivityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcThermalConductivityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcThermalConductivityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcThermalConductivityMeasure::is(Type::Enum v) const { return v == IfcThermalConductivityMeasure::Class(); }
Type::Enum IfcThermalConductivityMeasure::type() const { return Type::IfcThermalConductivityMeasure; }
@@ -6362,7 +6362,7 @@ IfcThermalConductivityMeasure::IfcThermalConductivityMeasure(double v) { IfcWrit
IfcThermalConductivityMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcThermalExpansionCoefficientMeasure
IfcUtil::ArgumentType IfcThermalExpansionCoefficientMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcThermalExpansionCoefficientMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcThermalExpansionCoefficientMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcThermalExpansionCoefficientMeasure::is(Type::Enum v) const { return v == IfcThermalExpansionCoefficientMeasure::Class(); }
Type::Enum IfcThermalExpansionCoefficientMeasure::type() const { return Type::IfcThermalExpansionCoefficientMeasure; }
@@ -6372,7 +6372,7 @@ IfcThermalExpansionCoefficientMeasure::IfcThermalExpansionCoefficientMeasure(dou
IfcThermalExpansionCoefficientMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcThermalResistanceMeasure
IfcUtil::ArgumentType IfcThermalResistanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcThermalResistanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcThermalResistanceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcThermalResistanceMeasure::is(Type::Enum v) const { return v == IfcThermalResistanceMeasure::Class(); }
Type::Enum IfcThermalResistanceMeasure::type() const { return Type::IfcThermalResistanceMeasure; }
@@ -6382,7 +6382,7 @@ IfcThermalResistanceMeasure::IfcThermalResistanceMeasure(double v) { IfcWritable
IfcThermalResistanceMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcThermalTransmittanceMeasure
IfcUtil::ArgumentType IfcThermalTransmittanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcThermalTransmittanceMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcThermalTransmittanceMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcThermalTransmittanceMeasure::is(Type::Enum v) const { return v == IfcThermalTransmittanceMeasure::Class(); }
Type::Enum IfcThermalTransmittanceMeasure::type() const { return Type::IfcThermalTransmittanceMeasure; }
@@ -6392,7 +6392,7 @@ IfcThermalTransmittanceMeasure::IfcThermalTransmittanceMeasure(double v) { IfcWr
IfcThermalTransmittanceMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcThermodynamicTemperatureMeasure
IfcUtil::ArgumentType IfcThermodynamicTemperatureMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcThermodynamicTemperatureMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcThermodynamicTemperatureMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcThermodynamicTemperatureMeasure::is(Type::Enum v) const { return v == IfcThermodynamicTemperatureMeasure::Class(); }
Type::Enum IfcThermodynamicTemperatureMeasure::type() const { return Type::IfcThermodynamicTemperatureMeasure; }
@@ -6402,7 +6402,7 @@ IfcThermodynamicTemperatureMeasure::IfcThermodynamicTemperatureMeasure(double v)
IfcThermodynamicTemperatureMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcTimeMeasure
IfcUtil::ArgumentType IfcTimeMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcTimeMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcTimeMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcTimeMeasure::is(Type::Enum v) const { return v == IfcTimeMeasure::Class(); }
Type::Enum IfcTimeMeasure::type() const { return Type::IfcTimeMeasure; }
@@ -6412,7 +6412,7 @@ IfcTimeMeasure::IfcTimeMeasure(double v) { IfcWritableEntity* e = new IfcWritabl
IfcTimeMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcTimeStamp
IfcUtil::ArgumentType IfcTimeStamp::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcTimeStamp::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcTimeStamp::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcTimeStamp::is(Type::Enum v) const { return v == IfcTimeStamp::Class(); }
Type::Enum IfcTimeStamp::type() const { return Type::IfcTimeStamp; }
@@ -6422,7 +6422,7 @@ IfcTimeStamp::IfcTimeStamp(int v) { IfcWritableEntity* e = new IfcWritableEntity
IfcTimeStamp::operator int() const { return *entity->getArgument(0); }
// Function implementations for IfcTorqueMeasure
IfcUtil::ArgumentType IfcTorqueMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcTorqueMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcTorqueMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcTorqueMeasure::is(Type::Enum v) const { return v == IfcTorqueMeasure::Class(); }
Type::Enum IfcTorqueMeasure::type() const { return Type::IfcTorqueMeasure; }
@@ -6432,7 +6432,7 @@ IfcTorqueMeasure::IfcTorqueMeasure(double v) { IfcWritableEntity* e = new IfcWri
IfcTorqueMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcVaporPermeabilityMeasure
IfcUtil::ArgumentType IfcVaporPermeabilityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcVaporPermeabilityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcVaporPermeabilityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcVaporPermeabilityMeasure::is(Type::Enum v) const { return v == IfcVaporPermeabilityMeasure::Class(); }
Type::Enum IfcVaporPermeabilityMeasure::type() const { return Type::IfcVaporPermeabilityMeasure; }
@@ -6442,7 +6442,7 @@ IfcVaporPermeabilityMeasure::IfcVaporPermeabilityMeasure(double v) { IfcWritable
IfcVaporPermeabilityMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcVolumeMeasure
IfcUtil::ArgumentType IfcVolumeMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcVolumeMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcVolumeMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcVolumeMeasure::is(Type::Enum v) const { return v == IfcVolumeMeasure::Class(); }
Type::Enum IfcVolumeMeasure::type() const { return Type::IfcVolumeMeasure; }
@@ -6452,7 +6452,7 @@ IfcVolumeMeasure::IfcVolumeMeasure(double v) { IfcWritableEntity* e = new IfcWri
IfcVolumeMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcVolumetricFlowRateMeasure
IfcUtil::ArgumentType IfcVolumetricFlowRateMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcVolumetricFlowRateMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcVolumetricFlowRateMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcVolumetricFlowRateMeasure::is(Type::Enum v) const { return v == IfcVolumetricFlowRateMeasure::Class(); }
Type::Enum IfcVolumetricFlowRateMeasure::type() const { return Type::IfcVolumetricFlowRateMeasure; }
@@ -6462,7 +6462,7 @@ IfcVolumetricFlowRateMeasure::IfcVolumetricFlowRateMeasure(double v) { IfcWritab
IfcVolumetricFlowRateMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcWarpingConstantMeasure
IfcUtil::ArgumentType IfcWarpingConstantMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcWarpingConstantMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcWarpingConstantMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcWarpingConstantMeasure::is(Type::Enum v) const { return v == IfcWarpingConstantMeasure::Class(); }
Type::Enum IfcWarpingConstantMeasure::type() const { return Type::IfcWarpingConstantMeasure; }
@@ -6472,7 +6472,7 @@ IfcWarpingConstantMeasure::IfcWarpingConstantMeasure(double v) { IfcWritableEnti
IfcWarpingConstantMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcWarpingMomentMeasure
IfcUtil::ArgumentType IfcWarpingMomentMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcWarpingMomentMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcWarpingMomentMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcWarpingMomentMeasure::is(Type::Enum v) const { return v == IfcWarpingMomentMeasure::Class(); }
Type::Enum IfcWarpingMomentMeasure::type() const { return Type::IfcWarpingMomentMeasure; }
@@ -6482,7 +6482,7 @@ IfcWarpingMomentMeasure::IfcWarpingMomentMeasure(double v) { IfcWritableEntity*
IfcWarpingMomentMeasure::operator double() const { return *entity->getArgument(0); }
// Function implementations for IfcYearNumber
IfcUtil::ArgumentType IfcYearNumber::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcException("argument out of range"); } }
IfcUtil::ArgumentType IfcYearNumber::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
Argument* IfcYearNumber::getArgument(unsigned int i) const { return entity->getArgument(i); }
bool IfcYearNumber::is(Type::Enum v) const { return v == IfcYearNumber::Class(); }
Type::Enum IfcYearNumber::type() const { return Type::IfcYearNumber; }
src/ifcparse/Ifc2x3.h
+303 -303
View File
File diff suppressed because it is too large Load Diff
src/ifcparse/Ifc4.cpp
+126 -126
View File
File diff suppressed because it is too large Load Diff
src/ifcparse/Ifc4.h
+177 -177
View File
@@ -8144,9 +8144,9 @@ public:
std::string Description() const;
void setDescription(std::string v);
virtual unsigned int getArgumentCount() const { return 3; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcRoleEnum; case 1: return Type::IfcLabel; case 2: return Type::IfcText; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Role"; case 1: return "UserDefinedRole"; case 2: return "Description"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcRoleEnum; case 1: return Type::IfcLabel; case 2: return Type::IfcText; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Role"; case 1: return "UserDefinedRole"; case 2: return "Description"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects
bool is(Type::Enum v) const;
@@ -8182,9 +8182,9 @@ public:
std::string UserDefinedPurpose() const;
void setUserDefinedPurpose(std::string v);
virtual unsigned int getArgumentCount() const { return 3; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAddressTypeEnum; case 1: return Type::IfcText; case 2: return Type::IfcLabel; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Purpose"; case 1: return "Description"; case 2: return "UserDefinedPurpose"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAddressTypeEnum; case 1: return Type::IfcText; case 2: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Purpose"; case 1: return "Description"; case 2: return "UserDefinedPurpose"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcPerson >::ptr OfPerson() const; // INVERSE IfcPerson::Addresses
IfcTemplatedEntityList< IfcOrganization >::ptr OfOrganization() const; // INVERSE IfcOrganization::Addresses
@@ -8213,9 +8213,9 @@ public:
std::string ApplicationIdentifier() const;
void setApplicationIdentifier(std::string v);
virtual unsigned int getArgumentCount() const { return 4; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcOrganization; case 1: return Type::IfcLabel; case 2: return Type::IfcLabel; case 3: return Type::IfcIdentifier; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ApplicationDeveloper"; case 1: return "Version"; case 2: return "ApplicationFullName"; case 3: return "ApplicationIdentifier"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcOrganization; case 1: return Type::IfcLabel; case 2: return Type::IfcLabel; case 3: return Type::IfcIdentifier; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ApplicationDeveloper"; case 1: return "Version"; case 2: return "ApplicationFullName"; case 3: return "ApplicationIdentifier"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -8295,9 +8295,9 @@ public:
IfcTemplatedEntityList< IfcAppliedValue >::ptr Components() const;
void setComponents(IfcTemplatedEntityList< IfcAppliedValue >::ptr v);
virtual unsigned int getArgumentCount() const { return 10; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_STRING; case 8: return IfcUtil::Argument_ENUMERATION; case 9: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcAppliedValueSelect; case 3: return Type::IfcMeasureWithUnit; case 4: return Type::IfcDate; case 5: return Type::IfcDate; case 6: return Type::IfcLabel; case 7: return Type::IfcLabel; case 8: return Type::IfcArithmeticOperatorEnum; case 9: return Type::IfcAppliedValue; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "AppliedValue"; case 3: return "UnitBasis"; case 4: return "ApplicableDate"; case 5: return "FixedUntilDate"; case 6: return "Category"; case 7: return "Condition"; case 8: return "ArithmeticOperator"; case 9: return "Components"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_STRING; case 8: return IfcUtil::Argument_ENUMERATION; case 9: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcAppliedValueSelect; case 3: return Type::IfcMeasureWithUnit; case 4: return Type::IfcDate; case 5: return Type::IfcDate; case 6: return Type::IfcLabel; case 7: return Type::IfcLabel; case 8: return Type::IfcArithmeticOperatorEnum; case 9: return Type::IfcAppliedValue; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "AppliedValue"; case 3: return "UnitBasis"; case 4: return "ApplicableDate"; case 5: return "FixedUntilDate"; case 6: return "Category"; case 7: return "Condition"; case 8: return "ArithmeticOperator"; case 9: return "Components"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects
bool is(Type::Enum v) const;
@@ -8366,9 +8366,9 @@ public:
IfcActorSelect* GivingApproval() const;
void setGivingApproval(IfcActorSelect* v);
virtual unsigned int getArgumentCount() const { return 9; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcDateTime; case 4: return Type::IfcLabel; case 5: return Type::IfcLabel; case 6: return Type::IfcText; case 7: return Type::IfcActorSelect; case 8: return Type::IfcActorSelect; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identifier"; case 1: return "Name"; case 2: return "Description"; case 3: return "TimeOfApproval"; case 4: return "Status"; case 5: return "Level"; case 6: return "Qualifier"; case 7: return "RequestingApproval"; case 8: return "GivingApproval"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcDateTime; case 4: return Type::IfcLabel; case 5: return Type::IfcLabel; case 6: return Type::IfcText; case 7: return Type::IfcActorSelect; case 8: return Type::IfcActorSelect; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identifier"; case 1: return "Name"; case 2: return "Description"; case 3: return "TimeOfApproval"; case 4: return "Status"; case 5: return "Level"; case 6: return "Qualifier"; case 7: return "RequestingApproval"; case 8: return "GivingApproval"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects
IfcTemplatedEntityList< IfcRelAssociatesApproval >::ptr ApprovedObjects() const; // INVERSE IfcRelAssociatesApproval::RelatingApproval
@@ -8405,9 +8405,9 @@ public:
std::string Name() const;
void setName(std::string v);
virtual unsigned int getArgumentCount() const { return 1; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -8608,9 +8608,9 @@ public:
class IfcConnectionGeometry : public IfcUtil::IfcBaseEntity {
public:
virtual unsigned int getArgumentCount() const { return 0; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -8764,9 +8764,9 @@ public:
std::string UserDefinedGrade() const;
void setUserDefinedGrade(std::string v);
virtual unsigned int getArgumentCount() const { return 7; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcConstraintEnum; case 3: return Type::IfcLabel; case 4: return Type::IfcActorSelect; case 5: return Type::IfcDateTime; case 6: return Type::IfcLabel; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "ConstraintGrade"; case 3: return "ConstraintSource"; case 4: return "CreatingActor"; case 5: return "CreationTime"; case 6: return "UserDefinedGrade"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcConstraintEnum; case 3: return Type::IfcLabel; case 4: return Type::IfcActorSelect; case 5: return Type::IfcDateTime; case 6: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "ConstraintGrade"; case 3: return "ConstraintSource"; case 4: return "CreatingActor"; case 5: return "CreationTime"; case 6: return "UserDefinedGrade"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects
IfcTemplatedEntityList< IfcResourceConstraintRelationship >::ptr PropertiesForConstraint() const; // INVERSE IfcResourceConstraintRelationship::RelatingConstraint
@@ -8832,9 +8832,9 @@ public:
IfcCoordinateReferenceSystem* TargetCRS() const;
void setTargetCRS(IfcCoordinateReferenceSystem* v);
virtual unsigned int getArgumentCount() const { return 2; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCoordinateReferenceSystemSelect; case 1: return Type::IfcCoordinateReferenceSystem; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SourceCRS"; case 1: return "TargetCRS"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCoordinateReferenceSystemSelect; case 1: return Type::IfcCoordinateReferenceSystem; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SourceCRS"; case 1: return "TargetCRS"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -8894,9 +8894,9 @@ public:
std::string VerticalDatum() const;
void setVerticalDatum(std::string v);
virtual unsigned int getArgumentCount() const { return 4; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcIdentifier; case 3: return Type::IfcIdentifier; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "GeodeticDatum"; case 3: return "VerticalDatum"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcIdentifier; case 3: return Type::IfcIdentifier; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "GeodeticDatum"; case 3: return "VerticalDatum"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -8981,9 +8981,9 @@ public:
std::string UserDefinedType() const;
void setUserDefinedType(std::string v);
virtual unsigned int getArgumentCount() const { return 3; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENUMERATION; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDerivedUnitElement; case 1: return Type::IfcDerivedUnitEnum; case 2: return Type::IfcLabel; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Elements"; case 1: return "UnitType"; case 2: return "UserDefinedType"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENUMERATION; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDerivedUnitElement; case 1: return Type::IfcDerivedUnitEnum; case 2: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Elements"; case 1: return "UnitType"; case 2: return "UserDefinedType"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -9010,9 +9010,9 @@ public:
int Exponent() const;
void setExponent(int v);
virtual unsigned int getArgumentCount() const { return 2; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_INT; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcNamedUnit; case 1: return Type::UNDEFINED; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Unit"; case 1: return "Exponent"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_INT; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcNamedUnit; case 1: return Type::UNDEFINED; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Unit"; case 1: return "Exponent"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -9062,9 +9062,9 @@ public:
int LuminousIntensityExponent() const;
void setLuminousIntensityExponent(int v);
virtual unsigned int getArgumentCount() const { return 7; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_INT; case 1: return IfcUtil::Argument_INT; case 2: return IfcUtil::Argument_INT; case 3: return IfcUtil::Argument_INT; case 4: return IfcUtil::Argument_INT; case 5: return IfcUtil::Argument_INT; case 6: return IfcUtil::Argument_INT; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::UNDEFINED; case 1: return Type::UNDEFINED; case 2: return Type::UNDEFINED; case 3: return Type::UNDEFINED; case 4: return Type::UNDEFINED; case 5: return Type::UNDEFINED; case 6: return Type::UNDEFINED; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "LengthExponent"; case 1: return "MassExponent"; case 2: return "TimeExponent"; case 3: return "ElectricCurrentExponent"; case 4: return "ThermodynamicTemperatureExponent"; case 5: return "AmountOfSubstanceExponent"; case 6: return "LuminousIntensityExponent"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_INT; case 1: return IfcUtil::Argument_INT; case 2: return IfcUtil::Argument_INT; case 3: return IfcUtil::Argument_INT; case 4: return IfcUtil::Argument_INT; case 5: return IfcUtil::Argument_INT; case 6: return IfcUtil::Argument_INT; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::UNDEFINED; case 1: return Type::UNDEFINED; case 2: return Type::UNDEFINED; case 3: return Type::UNDEFINED; case 4: return Type::UNDEFINED; case 5: return Type::UNDEFINED; case 6: return Type::UNDEFINED; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "LengthExponent"; case 1: return "MassExponent"; case 2: return "TimeExponent"; case 3: return "ElectricCurrentExponent"; case 4: return "ThermodynamicTemperatureExponent"; case 5: return "AmountOfSubstanceExponent"; case 6: return "LuminousIntensityExponent"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -9082,9 +9082,9 @@ public:
class IfcExternalInformation : public IfcUtil::IfcBaseEntity {
public:
virtual unsigned int getArgumentCount() const { return 0; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -9130,9 +9130,9 @@ public:
std::string Name() const;
void setName(std::string v);
virtual unsigned int getArgumentCount() const { return 3; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcURIReference; case 1: return Type::IfcIdentifier; case 2: return Type::IfcLabel; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Location"; case 1: return "Identification"; case 2: return "Name"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcURIReference; case 1: return Type::IfcIdentifier; case 2: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Location"; case 1: return "Identification"; case 2: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr ExternalReferenceForResources() const; // INVERSE IfcExternalReferenceRelationship::RelatingReference
bool is(Type::Enum v) const;
@@ -9243,9 +9243,9 @@ public:
bool SameSense() const;
void setSameSense(bool v);
virtual unsigned int getArgumentCount() const { return 3; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_BOOL; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcCurve; case 2: return Type::IfcBoolean; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "AxisTag"; case 1: return "AxisCurve"; case 2: return "SameSense"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_BOOL; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcCurve; case 2: return Type::IfcBoolean; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "AxisTag"; case 1: return "AxisCurve"; case 2: return "SameSense"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcGrid >::ptr PartOfW() const; // INVERSE IfcGrid::WAxes
IfcTemplatedEntityList< IfcGrid >::ptr PartOfV() const; // INVERSE IfcGrid::VAxes
@@ -9270,9 +9270,9 @@ public:
IfcEntityList::ptr ListValues() const;
void setListValues(IfcEntityList::ptr v);
virtual unsigned int getArgumentCount() const { return 2; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDateTime; case 1: return Type::IfcValue; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TimeStamp"; case 1: return "ListValues"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDateTime; case 1: return Type::IfcValue; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TimeStamp"; case 1: return "ListValues"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -9406,9 +9406,9 @@ public:
std::vector< double > /*[1:?]*/ LuminousIntensity() const;
void setLuminousIntensity(std::vector< double > /*[1:?]*/ v);
virtual unsigned int getArgumentCount() const { return 3; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_DOUBLE; case 1: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; case 2: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPlaneAngleMeasure; case 1: return Type::IfcPlaneAngleMeasure; case 2: return Type::IfcLuminousIntensityDistributionMeasure; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MainPlaneAngle"; case 1: return "SecondaryPlaneAngle"; case 2: return "LuminousIntensity"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_DOUBLE; case 1: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; case 2: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPlaneAngleMeasure; case 1: return Type::IfcPlaneAngleMeasure; case 2: return Type::IfcLuminousIntensityDistributionMeasure; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MainPlaneAngle"; case 1: return "SecondaryPlaneAngle"; case 2: return "LuminousIntensity"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -9429,9 +9429,9 @@ public:
IfcTemplatedEntityList< IfcLightDistributionData >::ptr DistributionData() const;
void setDistributionData(IfcTemplatedEntityList< IfcLightDistributionData >::ptr v);
virtual unsigned int getArgumentCount() const { return 2; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLightDistributionCurveEnum; case 1: return Type::IfcLightDistributionData; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "LightDistributionCurve"; case 1: return "DistributionData"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLightDistributionCurveEnum; case 1: return Type::IfcLightDistributionData; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "LightDistributionCurve"; case 1: return "DistributionData"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -9510,9 +9510,9 @@ public:
IfcMaterial* ClassifiedMaterial() const;
void setClassifiedMaterial(IfcMaterial* v);
virtual unsigned int getArgumentCount() const { return 2; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcClassificationSelect; case 1: return Type::IfcMaterial; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MaterialClassifications"; case 1: return "ClassifiedMaterial"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcClassificationSelect; case 1: return Type::IfcMaterial; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MaterialClassifications"; case 1: return "ClassifiedMaterial"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -9548,9 +9548,9 @@ public:
class IfcMaterialDefinition : public IfcUtil::IfcBaseEntity {
public:
virtual unsigned int getArgumentCount() const { return 0; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcRelAssociatesMaterial >::ptr AssociatedTo() const; // INVERSE IfcRelAssociatesMaterial::RelatingMaterial
IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects
@@ -9789,9 +9789,9 @@ public:
IfcTemplatedEntityList< IfcMaterial >::ptr Materials() const;
void setMaterials(IfcTemplatedEntityList< IfcMaterial >::ptr v);
virtual unsigned int getArgumentCount() const { return 1; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcMaterial; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Materials"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcMaterial; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Materials"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -9944,9 +9944,9 @@ public:
class IfcMaterialUsageDefinition : public IfcUtil::IfcBaseEntity {
public:
virtual unsigned int getArgumentCount() const { return 0; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcRelAssociatesMaterial >::ptr AssociatedTo() const; // INVERSE IfcRelAssociatesMaterial::RelatingMaterial
bool is(Type::Enum v) const;
@@ -9975,9 +9975,9 @@ public:
IfcUnit* UnitComponent() const;
void setUnitComponent(IfcUnit* v);
virtual unsigned int getArgumentCount() const { return 2; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcValue; case 1: return Type::IfcUnit; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ValueComponent"; case 1: return "UnitComponent"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcValue; case 1: return Type::IfcUnit; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ValueComponent"; case 1: return "UnitComponent"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -10078,9 +10078,9 @@ public:
std::string Currency() const;
void setCurrency(std::string v);
virtual unsigned int getArgumentCount() const { return 1; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Currency"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Currency"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -10103,9 +10103,9 @@ public:
IfcUnitEnum::IfcUnitEnum UnitType() const;
void setUnitType(IfcUnitEnum::IfcUnitEnum v);
virtual unsigned int getArgumentCount() const { return 2; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENUMERATION; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDimensionalExponents; case 1: return Type::IfcUnitEnum; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Dimensions"; case 1: return "UnitType"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENUMERATION; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDimensionalExponents; case 1: return Type::IfcUnitEnum; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Dimensions"; case 1: return "UnitType"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -10128,9 +10128,9 @@ public:
class IfcObjectPlacement : public IfcUtil::IfcBaseEntity {
public:
virtual unsigned int getArgumentCount() const { return 0; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcProduct >::ptr PlacesObject() const; // INVERSE IfcProduct::ObjectPlacement
IfcTemplatedEntityList< IfcLocalPlacement >::ptr ReferencedByPlacements() const; // INVERSE IfcLocalPlacement::PlacementRelTo
@@ -10216,9 +10216,9 @@ public:
IfcTemplatedEntityList< IfcAddress >::ptr Addresses() const;
void setAddresses(IfcTemplatedEntityList< IfcAddress >::ptr v);
virtual unsigned int getArgumentCount() const { return 5; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcActorRole; case 4: return Type::IfcAddress; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identification"; case 1: return "Name"; case 2: return "Description"; case 3: return "Roles"; case 4: return "Addresses"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcActorRole; case 4: return Type::IfcAddress; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identification"; case 1: return "Name"; case 2: return "Description"; case 3: return "Roles"; case 4: return "Addresses"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcOrganizationRelationship >::ptr IsRelatedBy() const; // INVERSE IfcOrganizationRelationship::RelatedOrganizations
IfcTemplatedEntityList< IfcOrganizationRelationship >::ptr Relates() const; // INVERSE IfcOrganizationRelationship::RelatingOrganization
@@ -10277,9 +10277,9 @@ public:
int CreationDate() const;
void setCreationDate(int v);
virtual unsigned int getArgumentCount() const { return 8; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_ENUMERATION; case 4: return IfcUtil::Argument_INT; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_INT; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPersonAndOrganization; case 1: return Type::IfcApplication; case 2: return Type::IfcStateEnum; case 3: return Type::IfcChangeActionEnum; case 4: return Type::IfcTimeStamp; case 5: return Type::IfcPersonAndOrganization; case 6: return Type::IfcApplication; case 7: return Type::IfcTimeStamp; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "OwningUser"; case 1: return "OwningApplication"; case 2: return "State"; case 3: return "ChangeAction"; case 4: return "LastModifiedDate"; case 5: return "LastModifyingUser"; case 6: return "LastModifyingApplication"; case 7: return "CreationDate"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_ENUMERATION; case 4: return IfcUtil::Argument_INT; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_INT; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPersonAndOrganization; case 1: return Type::IfcApplication; case 2: return Type::IfcStateEnum; case 3: return Type::IfcChangeActionEnum; case 4: return Type::IfcTimeStamp; case 5: return Type::IfcPersonAndOrganization; case 6: return Type::IfcApplication; case 7: return Type::IfcTimeStamp; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "OwningUser"; case 1: return "OwningApplication"; case 2: return "State"; case 3: return "ChangeAction"; case 4: return "LastModifiedDate"; case 5: return "LastModifyingUser"; case 6: return "LastModifyingApplication"; case 7: return "CreationDate"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -10346,9 +10346,9 @@ public:
IfcTemplatedEntityList< IfcAddress >::ptr Addresses() const;
void setAddresses(IfcTemplatedEntityList< IfcAddress >::ptr v);
virtual unsigned int getArgumentCount() const { return 8; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 4: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 5: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 6: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcLabel; case 3: return Type::IfcLabel; case 4: return Type::IfcLabel; case 5: return Type::IfcLabel; case 6: return Type::IfcActorRole; case 7: return Type::IfcAddress; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identification"; case 1: return "FamilyName"; case 2: return "GivenName"; case 3: return "MiddleNames"; case 4: return "PrefixTitles"; case 5: return "SuffixTitles"; case 6: return "Roles"; case 7: return "Addresses"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 4: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 5: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 6: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcLabel; case 3: return Type::IfcLabel; case 4: return Type::IfcLabel; case 5: return Type::IfcLabel; case 6: return Type::IfcActorRole; case 7: return Type::IfcAddress; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identification"; case 1: return "FamilyName"; case 2: return "GivenName"; case 3: return "MiddleNames"; case 4: return "PrefixTitles"; case 5: return "SuffixTitles"; case 6: return "Roles"; case 7: return "Addresses"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcPersonAndOrganization >::ptr EngagedIn() const; // INVERSE IfcPersonAndOrganization::ThePerson
bool is(Type::Enum v) const;
@@ -10377,9 +10377,9 @@ public:
IfcTemplatedEntityList< IfcActorRole >::ptr Roles() const;
void setRoles(IfcTemplatedEntityList< IfcActorRole >::ptr v);
virtual unsigned int getArgumentCount() const { return 3; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPerson; case 1: return Type::IfcOrganization; case 2: return Type::IfcActorRole; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ThePerson"; case 1: return "TheOrganization"; case 2: return "Roles"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPerson; case 1: return Type::IfcOrganization; case 2: return Type::IfcActorRole; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ThePerson"; case 1: return "TheOrganization"; case 2: return "Roles"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -10404,9 +10404,9 @@ public:
std::string Description() const;
void setDescription(std::string v);
virtual unsigned int getArgumentCount() const { return 2; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects
IfcTemplatedEntityList< IfcPhysicalComplexQuantity >::ptr PartOfComplex() const; // INVERSE IfcPhysicalComplexQuantity::HasQuantities
@@ -10507,9 +10507,9 @@ public:
class IfcPresentationItem : public IfcUtil::IfcBaseEntity {
public:
virtual unsigned int getArgumentCount() const { return 0; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -10552,9 +10552,9 @@ public:
std::string Identifier() const;
void setIdentifier(std::string v);
virtual unsigned int getArgumentCount() const { return 4; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcLayeredItem; case 3: return Type::IfcIdentifier; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "AssignedItems"; case 3: return "Identifier"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcLayeredItem; case 3: return Type::IfcIdentifier; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "AssignedItems"; case 3: return "Identifier"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -10619,9 +10619,9 @@ public:
std::string Name() const;
void setName(std::string v);
virtual unsigned int getArgumentCount() const { return 1; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -10641,9 +10641,9 @@ public:
IfcEntityList::ptr Styles() const;
void setStyles(IfcEntityList::ptr v);
virtual unsigned int getArgumentCount() const { return 1; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPresentationStyleSelect; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Styles"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPresentationStyleSelect; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Styles"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -10685,9 +10685,9 @@ public:
IfcTemplatedEntityList< IfcRepresentation >::ptr Representations() const;
void setRepresentations(IfcTemplatedEntityList< IfcRepresentation >::ptr v);
virtual unsigned int getArgumentCount() const { return 3; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcRepresentation; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "Representations"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcRepresentation; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "Representations"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -10877,9 +10877,9 @@ public:
std::string ProfileName() const;
void setProfileName(std::string v);
virtual unsigned int getArgumentCount() const { return 2; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcProfileTypeEnum; case 1: return Type::IfcLabel; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ProfileType"; case 1: return "ProfileName"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcProfileTypeEnum; case 1: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ProfileType"; case 1: return "ProfileName"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects
IfcTemplatedEntityList< IfcProfileProperties >::ptr HasProperties() const; // INVERSE IfcProfileProperties::ProfileDefinition
@@ -10953,9 +10953,9 @@ public:
class IfcPropertyAbstraction : public IfcUtil::IfcBaseEntity {
public:
virtual unsigned int getArgumentCount() const { return 0; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects
bool is(Type::Enum v) const;
@@ -11270,9 +11270,9 @@ public:
IfcTemplatedEntityList< IfcTimePeriod >::ptr TimePeriods() const;
void setTimePeriods(IfcTemplatedEntityList< IfcTimePeriod >::ptr v);
virtual unsigned int getArgumentCount() const { return 8; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_AGGREGATE_OF_INT; case 2: return IfcUtil::Argument_AGGREGATE_OF_INT; case 3: return IfcUtil::Argument_AGGREGATE_OF_INT; case 4: return IfcUtil::Argument_INT; case 5: return IfcUtil::Argument_INT; case 6: return IfcUtil::Argument_INT; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcRecurrenceTypeEnum; case 1: return Type::IfcDayInMonthNumber; case 2: return Type::IfcDayInWeekNumber; case 3: return Type::IfcMonthInYearNumber; case 4: return Type::IfcInteger; case 5: return Type::IfcInteger; case 6: return Type::IfcInteger; case 7: return Type::IfcTimePeriod; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RecurrenceType"; case 1: return "DayComponent"; case 2: return "WeekdayComponent"; case 3: return "MonthComponent"; case 4: return "Position"; case 5: return "Interval"; case 6: return "Occurrences"; case 7: return "TimePeriods"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_AGGREGATE_OF_INT; case 2: return IfcUtil::Argument_AGGREGATE_OF_INT; case 3: return IfcUtil::Argument_AGGREGATE_OF_INT; case 4: return IfcUtil::Argument_INT; case 5: return IfcUtil::Argument_INT; case 6: return IfcUtil::Argument_INT; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcRecurrenceTypeEnum; case 1: return Type::IfcDayInMonthNumber; case 2: return Type::IfcDayInWeekNumber; case 3: return Type::IfcMonthInYearNumber; case 4: return Type::IfcInteger; case 5: return Type::IfcInteger; case 6: return Type::IfcInteger; case 7: return Type::IfcTimePeriod; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RecurrenceType"; case 1: return "DayComponent"; case 2: return "WeekdayComponent"; case 3: return "MonthComponent"; case 4: return "Position"; case 5: return "Interval"; case 6: return "Occurrences"; case 7: return "TimePeriods"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -11305,9 +11305,9 @@ public:
IfcReference* InnerReference() const;
void setInnerReference(IfcReference* v);
virtual unsigned int getArgumentCount() const { return 5; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_INT; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcIdentifier; case 2: return Type::IfcLabel; case 3: return Type::UNDEFINED; case 4: return Type::IfcReference; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TypeIdentifier"; case 1: return "AttributeIdentifier"; case 2: return "InstanceName"; case 3: return "ListPositions"; case 4: return "InnerReference"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_INT; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcIdentifier; case 2: return Type::IfcLabel; case 3: return Type::UNDEFINED; case 4: return Type::IfcReference; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TypeIdentifier"; case 1: return "AttributeIdentifier"; case 2: return "InstanceName"; case 3: return "ListPositions"; case 4: return "InnerReference"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -11382,9 +11382,9 @@ public:
IfcTemplatedEntityList< IfcRepresentationItem >::ptr Items() const;
void setItems(IfcTemplatedEntityList< IfcRepresentationItem >::ptr v);
virtual unsigned int getArgumentCount() const { return 4; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcRepresentationContext; case 1: return Type::IfcLabel; case 2: return Type::IfcLabel; case 3: return Type::IfcRepresentationItem; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ContextOfItems"; case 1: return "RepresentationIdentifier"; case 2: return "RepresentationType"; case 3: return "Items"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcRepresentationContext; case 1: return Type::IfcLabel; case 2: return Type::IfcLabel; case 3: return Type::IfcRepresentationItem; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ContextOfItems"; case 1: return "RepresentationIdentifier"; case 2: return "RepresentationType"; case 3: return "Items"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcRepresentationMap >::ptr RepresentationMap() const; // INVERSE IfcRepresentationMap::MappedRepresentation
IfcTemplatedEntityList< IfcPresentationLayerAssignment >::ptr LayerAssignments() const; // INVERSE IfcPresentationLayerAssignment::AssignedItems
@@ -11419,9 +11419,9 @@ public:
std::string ContextType() const;
void setContextType(std::string v);
virtual unsigned int getArgumentCount() const { return 2; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcLabel; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ContextIdentifier"; case 1: return "ContextType"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ContextIdentifier"; case 1: return "ContextType"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcRepresentation >::ptr RepresentationsInContext() const; // INVERSE IfcRepresentation::ContextOfItems
bool is(Type::Enum v) const;
@@ -11466,9 +11466,9 @@ public:
class IfcRepresentationItem : public IfcUtil::IfcBaseEntity {
public:
virtual unsigned int getArgumentCount() const { return 0; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcPresentationLayerAssignment >::ptr LayerAssignment() const; // INVERSE IfcPresentationLayerAssignment::AssignedItems
IfcTemplatedEntityList< IfcStyledItem >::ptr StyledByItem() const; // INVERSE IfcStyledItem::Item
@@ -11500,9 +11500,9 @@ public:
IfcRepresentation* MappedRepresentation() const;
void setMappedRepresentation(IfcRepresentation* v);
virtual unsigned int getArgumentCount() const { return 2; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAxis2Placement; case 1: return Type::IfcRepresentation; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MappingOrigin"; case 1: return "MappedRepresentation"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAxis2Placement; case 1: return Type::IfcRepresentation; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MappingOrigin"; case 1: return "MappedRepresentation"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcShapeAspect >::ptr HasShapeAspects() const; // INVERSE IfcShapeAspect::PartOfProductDefinitionShape
IfcTemplatedEntityList< IfcMappedItem >::ptr MapUsage() const; // INVERSE IfcMappedItem::MappingSource
@@ -11529,9 +11529,9 @@ public:
std::string Description() const;
void setDescription(std::string v);
virtual unsigned int getArgumentCount() const { return 2; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -11574,9 +11574,9 @@ public:
std::string Description() const;
void setDescription(std::string v);
virtual unsigned int getArgumentCount() const { return 4; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcGloballyUniqueId; case 1: return Type::IfcOwnerHistory; case 2: return Type::IfcLabel; case 3: return Type::IfcText; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "GlobalId"; case 1: return "OwnerHistory"; case 2: return "Name"; case 3: return "Description"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcGloballyUniqueId; case 1: return Type::IfcOwnerHistory; case 2: return Type::IfcLabel; case 3: return Type::IfcText; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "GlobalId"; case 1: return "OwnerHistory"; case 2: return "Name"; case 3: return "Description"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -11638,9 +11638,9 @@ public:
std::string UserDefinedDataOrigin() const;
void setUserDefinedDataOrigin(std::string v);
virtual unsigned int getArgumentCount() const { return 3; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENUMERATION; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcDataOriginEnum; case 2: return Type::IfcLabel; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "DataOrigin"; case 2: return "UserDefinedDataOrigin"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENUMERATION; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcDataOriginEnum; case 2: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "DataOrigin"; case 2: return "UserDefinedDataOrigin"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -11714,9 +11714,9 @@ public:
IfcProductRepresentationSelect* PartOfProductDefinitionShape() const;
void setPartOfProductDefinitionShape(IfcProductRepresentationSelect* v);
virtual unsigned int getArgumentCount() const { return 5; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_BOOL; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcShapeModel; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::UNDEFINED; case 4: return Type::IfcProductRepresentationSelect; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ShapeRepresentations"; case 1: return "Name"; case 2: return "Description"; case 3: return "ProductDefinitional"; case 4: return "PartOfProductDefinitionShape"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_BOOL; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcShapeModel; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::UNDEFINED; case 4: return Type::IfcProductRepresentationSelect; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ShapeRepresentations"; case 1: return "Name"; case 2: return "Description"; case 3: return "ProductDefinitional"; case 4: return "PartOfProductDefinitionShape"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -11918,9 +11918,9 @@ public:
std::string Name() const;
void setName(std::string v);
virtual unsigned int getArgumentCount() const { return 1; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -11940,9 +11940,9 @@ public:
std::string Name() const;
void setName(std::string v);
virtual unsigned int getArgumentCount() const { return 1; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -12523,9 +12523,9 @@ public:
IfcTemplatedEntityList< IfcTableColumn >::ptr Columns() const;
void setColumns(IfcTemplatedEntityList< IfcTableColumn >::ptr v);
virtual unsigned int getArgumentCount() const { return 3; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcTableRow; case 2: return Type::IfcTableColumn; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Rows"; case 2: return "Columns"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcTableRow; case 2: return Type::IfcTableColumn; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Rows"; case 2: return "Columns"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -12566,9 +12566,9 @@ public:
IfcReference* ReferencePath() const;
void setReferencePath(IfcReference* v);
virtual unsigned int getArgumentCount() const { return 5; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcUnit; case 4: return Type::IfcReference; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identifier"; case 1: return "Name"; case 2: return "Description"; case 3: return "Unit"; case 4: return "ReferencePath"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcUnit; case 4: return Type::IfcReference; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identifier"; case 1: return "Name"; case 2: return "Description"; case 3: return "Unit"; case 4: return "ReferencePath"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -12603,9 +12603,9 @@ public:
bool IsHeading() const;
void setIsHeading(bool v);
virtual unsigned int getArgumentCount() const { return 2; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_BOOL; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcValue; case 1: return Type::UNDEFINED; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RowCells"; case 1: return "IsHeading"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_BOOL; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcValue; case 1: return Type::UNDEFINED; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RowCells"; case 1: return "IsHeading"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcTable >::ptr OfTable() const; // INVERSE IfcTable::Rows
bool is(Type::Enum v) const;
@@ -13242,9 +13242,9 @@ public:
std::string EndTime() const;
void setEndTime(std::string v);
virtual unsigned int getArgumentCount() const { return 2; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcTime; case 1: return Type::IfcTime; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "StartTime"; case 1: return "EndTime"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcTime; case 1: return Type::IfcTime; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "StartTime"; case 1: return "EndTime"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -13291,9 +13291,9 @@ public:
IfcUnit* Unit() const;
void setUnit(IfcUnit* v);
virtual unsigned int getArgumentCount() const { return 8; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_ENUMERATION; case 5: return IfcUtil::Argument_ENUMERATION; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcDateTime; case 3: return Type::IfcDateTime; case 4: return Type::IfcTimeSeriesDataTypeEnum; case 5: return Type::IfcDataOriginEnum; case 6: return Type::IfcLabel; case 7: return Type::IfcUnit; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "StartTime"; case 3: return "EndTime"; case 4: return "TimeSeriesDataType"; case 5: return "DataOrigin"; case 6: return "UserDefinedDataOrigin"; case 7: return "Unit"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_ENUMERATION; case 5: return IfcUtil::Argument_ENUMERATION; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcDateTime; case 3: return Type::IfcDateTime; case 4: return Type::IfcTimeSeriesDataTypeEnum; case 5: return Type::IfcDataOriginEnum; case 6: return Type::IfcLabel; case 7: return Type::IfcUnit; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "StartTime"; case 3: return "EndTime"; case 4: return "TimeSeriesDataType"; case 5: return "DataOrigin"; case 6: return "UserDefinedDataOrigin"; case 7: return "Unit"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects
bool is(Type::Enum v) const;
@@ -13318,9 +13318,9 @@ public:
IfcEntityList::ptr ListValues() const;
void setListValues(IfcEntityList::ptr v);
virtual unsigned int getArgumentCount() const { return 1; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcValue; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ListValues"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcValue; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ListValues"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -13407,9 +13407,9 @@ public:
IfcEntityList::ptr Units() const;
void setUnits(IfcEntityList::ptr v);
virtual unsigned int getArgumentCount() const { return 1; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcUnit; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Units"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcUnit; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Units"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
@@ -13536,9 +13536,9 @@ public:
std::vector< double > /*[2:3]*/ OffsetDistances() const;
void setOffsetDistances(std::vector< double > /*[2:3]*/ v);
virtual unsigned int getArgumentCount() const { return 2; }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; } throw IfcParse::IfcException("argument out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcGridAxis; case 1: return Type::IfcLengthMeasure; } throw IfcParse::IfcException("argument out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "IntersectingAxes"; case 1: return "OffsetDistances"; } throw IfcParse::IfcException("argument out of range"); }
virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcGridAxis; case 1: return Type::IfcLengthMeasure; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "IntersectingAxes"; case 1: return "OffsetDistances"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
bool is(Type::Enum v) const;
Type::Enum type() const;
src/ifcparse/IfcEntityDescriptor.h
+1 -1
View File
@@ -82,7 +82,7 @@ namespace IfcUtil {
}
const IfcArgumentDescriptor& get_argument(unsigned i) const {
if (i < arguments.size()) return arguments[i];
else throw IfcParse::IfcException("Argument out of range");
else throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range");
}
public:
IfcEntityDescriptor(IfcSchema::Type::Enum type, IfcEntityDescriptor* parent)
src/ifcparse/IfcException.h
+14 -4
View File
@@ -26,11 +26,21 @@
namespace IfcParse {
class IfcException : public std::exception {
private:
std::string error;
std::string message;
public:
IfcException(std::string e);
~IfcException () throw ();
const char* what() const throw();
IfcException(const std::string& m)
: message(m) {}
~IfcException () throw () {}
const char* what() const throw() {
return message.c_str();
}
};
class IfcAttributeOutOfRangeException : public IfcException {
public:
IfcAttributeOutOfRangeException(const std::string& e)
: IfcException(e) {}
~IfcAttributeOutOfRangeException () throw () {}
};
}
src/ifcparse/IfcParse.cpp
+5 -9
View File
@@ -650,7 +650,7 @@ unsigned int ArgumentList::size() const { return (unsigned int) list.size(); }
Argument* ArgumentList::operator [] (unsigned int i) const {
if ( i >= list.size() ) {
throw IfcException("Argument index out of range");
throw IfcAttributeOutOfRangeException("Argument index out of range");
}
return list[i];
}
@@ -951,7 +951,7 @@ bool IfcFile::Init(IfcParse::IfcSpfStream* s) {
} else {
entity = IfcSchema::SchemaEntity(e);
}
} catch (IfcException ex) {
} catch (const IfcException& ex) {
currentId = 0;
Logger::Message(Logger::LOG_ERROR,ex.what());
continue;
@@ -971,7 +971,7 @@ bool IfcFile::Init(IfcParse::IfcSpfStream* s) {
Logger::Message(Logger::LOG_WARNING,ss.str());
}
byguid[guid] = ifc_root;
} catch (IfcException ex) {
} catch (const IfcException& ex) {
Logger::Message(Logger::LOG_ERROR,ex.what());
}
}
@@ -1176,7 +1176,7 @@ IfcUtil::IfcBaseClass* IfcFile::addEntity(IfcUtil::IfcBaseClass* entity) {
Logger::Message(Logger::LOG_WARNING,ss.str());
}
byguid[guid] = ifc_root;
} catch (IfcException ex) {
} catch (const IfcException& ex) {
Logger::Message(Logger::LOG_ERROR,ex.what());
}
}
@@ -1230,7 +1230,7 @@ IfcUtil::IfcBaseClass* IfcFile::addEntity(IfcUtil::IfcBaseClass* entity) {
}
refs->push(entity);
}
} catch (IfcParse::IfcException&) {}
} catch (const IfcParse::IfcException&) {}
}
return entity;
@@ -1382,10 +1382,6 @@ IfcSchema::IfcRoot* IfcFile::entityByGuid(const std::string& guid) {
}
}
IfcException::IfcException(std::string e) { error = e; }
IfcException::~IfcException() throw () {}
const char* IfcException::what() const throw() { return error.c_str(); }
// FIXME: Test destructor to delete entity and arg allocations
IfcFile::~IfcFile() {
for( entity_by_id_t::const_iterator it = byid.begin(); it != byid.end(); ++ it ) {
src/ifcparse/IfcUtil.cpp
+1 -1
View File
@@ -71,7 +71,7 @@ IfcEntityList::ptr IfcEntityList::filtered(const std::set<IfcSchema::Type::Enum>
unsigned int IfcUtil::IfcBaseType::getArgumentCount() const { return 1; }
Argument* IfcUtil::IfcBaseType::getArgument(unsigned int i) const { return entity->getArgument(i); }
const char* IfcUtil::IfcBaseType::getArgumentName(unsigned int i) const { if (i == 0) { return "wrappedValue"; } else { throw IfcParse::IfcException("argument out of range"); } }
const char* IfcUtil::IfcBaseType::getArgumentName(unsigned int i) const { if (i == 0) { return "wrappedValue"; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } }
void Logger::SetOutput(std::ostream* l1, std::ostream* l2) {
log1 = l1;